@ruiapp/rapid-core 0.0.1

package/dist/index.js

@@ -0,0 +1,3590 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _ = require('lodash');
+var Router = require('koa-tree-router');
+var qs = require('qs');
+var events = require('events');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n["default"] = e;
+  return Object.freeze(n);
+}
+
+var ___namespace = /*#__PURE__*/_interopNamespace(_);
+var Router__default = /*#__PURE__*/_interopDefaultLegacy(Router);
+var qs__default = /*#__PURE__*/_interopDefaultLegacy(qs);
+
+function fixBigIntJSONSerialize() {
+    BigInt.prototype.toJSON = function () {
+        return this.toString();
+    };
+}
+
+class DataAccessor {
+    #model;
+    #queryBuilder;
+    #databaseAccessor;
+    constructor(options) {
+        this.#queryBuilder = options.queryBuilder;
+        this.#model = options.model;
+    }
+    getModel() {
+        return this.#model;
+    }
+    async create(entity) {
+        const options = {
+            entity,
+        };
+        const query = this.#queryBuilder.insert(this.#model, options);
+        const result = await this.#databaseAccessor.queryDatabaseObject(query.command, query.params);
+        return ___namespace.first(result);
+    }
+    async updateById(id, entity) {
+        const options = {
+            entity,
+            filters: [
+                {
+                    field: "id",
+                    operator: "eq",
+                    value: id,
+                },
+            ],
+        };
+        const query = this.#queryBuilder.update(this.#model, options);
+        const result = await this.#databaseAccessor.queryDatabaseObject(query.command, query.params);
+        return ___namespace.first(result);
+    }
+    async find(options) {
+        console.debug("DataAccessor.find() with options:", options);
+        const query = this.#queryBuilder.select(this.#model, options);
+        return await this.#databaseAccessor.queryDatabaseObject(query.command, query.params);
+    }
+    async findOne(options) {
+        ___namespace.set(options, "pagination.limit", 1);
+        const list = await this.find(options);
+        return ___namespace.first(list);
+    }
+    async findById(id) {
+        const options = {
+            filters: [
+                {
+                    field: "id",
+                    operator: "eq",
+                    value: id,
+                },
+            ],
+        };
+        const query = this.#queryBuilder.select(this.#model, options);
+        const result = await this.#databaseAccessor.queryDatabaseObject(query.command, query.params);
+        return ___namespace.first(result);
+    }
+    async count(options) {
+        const query = this.#queryBuilder.count(this.#model, options);
+        const result = await this.#databaseAccessor.queryDatabaseObject(query.command, query.params);
+        const row = ___namespace.first(result);
+        if (row) {
+            return row;
+        }
+        return {
+            count: 0,
+        };
+    }
+    async deleteById(id) {
+        const options = {
+            filters: [
+                {
+                    field: "id",
+                    operator: "eq",
+                    value: id,
+                },
+            ],
+        };
+        const query = this.#queryBuilder.delete(this.#model, options);
+        await this.#databaseAccessor.queryDatabaseObject(query.command, query.params);
+    }
+}
+
+const objLeftQuoteChar = '"';
+const objRightQuoteChar = '"';
+const relationalOperatorsMap = new Map([
+    ["eq", "="],
+    ["ne", "<>"],
+    ["gt", ">"],
+    ["gte", ">="],
+    ["lt", "<"],
+    ["lte", "<="],
+]);
+class QueryBuilder {
+    #dbDefaultSchema;
+    constructor(options) {
+        this.#dbDefaultSchema = options.dbDefaultSchema;
+    }
+    quoteTable(options) {
+        const { schema, tableName } = options;
+        if (schema) {
+            return `${this.quoteObject(schema)}.${this.quoteObject(tableName)}`;
+        }
+        else if (this.#dbDefaultSchema) {
+            return `${this.quoteObject(this.#dbDefaultSchema)}.${this.quoteObject(tableName)}`;
+        }
+        else {
+            return this.quoteObject(tableName);
+        }
+    }
+    quoteObject(name) {
+        return `${objLeftQuoteChar}${name}${objRightQuoteChar}`;
+    }
+    select(model, options) {
+        const ctx = {
+            params: [],
+        };
+        let { properties, filters, orderBy, pagination } = options;
+        let command = "SELECT ";
+        if (!properties || !properties.length) {
+            command += "* FROM ";
+        }
+        else {
+            command += properties.map(this.quoteObject).join(", ");
+            command += " FROM ";
+        }
+        command += this.quoteTable(model);
+        if (filters && filters.length) {
+            command += " WHERE ";
+            command += buildFiltersQuery(ctx, filters);
+        }
+        if (orderBy && orderBy.length) {
+            command += " ORDER BY ";
+            command += orderBy.map((item) => {
+                const quotedName = this.quoteObject(item.field);
+                return item.desc ? quotedName + " DESC" : quotedName;
+            }).join(", ");
+        }
+        if (pagination) {
+            command += " OFFSET ";
+            ctx.params.push(pagination.offset);
+            command += "$" + ctx.params.length;
+            command += " LIMIT ";
+            ctx.params.push(pagination.limit);
+            command += "$" + ctx.params.length;
+        }
+        return {
+            command,
+            params: ctx.params,
+        };
+    }
+    count(model, options) {
+        const ctx = {
+            params: [],
+        };
+        let { filters } = options;
+        let command = 'SELECT COUNT(*)::int as "count" FROM ';
+        command += this.quoteTable(model);
+        if (filters && filters.length) {
+            command += " WHERE ";
+            command += buildFiltersQuery(ctx, filters);
+        }
+        return {
+            command,
+            params: ctx.params,
+        };
+    }
+    insert(model, options) {
+        const params = [];
+        const ctx = {
+            params,
+        };
+        const { entity } = options;
+        let command = "INSERT INTO ";
+        command += this.quoteTable(model);
+        const propertyNames = Object.keys(entity);
+        let values = "";
+        propertyNames.forEach((propertyName, index) => {
+            if (index) {
+                values += ", ";
+            }
+            let property = null;
+            if (model) {
+                property = ___namespace.find(model.properties, (e) => e.code === propertyName);
+            }
+            if (property && property.type === "json") {
+                params.push(JSON.stringify(entity[propertyName]));
+                values += `$${params.length}::jsonb`;
+            }
+            else {
+                params.push(entity[propertyName]);
+                values += `$${params.length}`;
+            }
+        });
+        command += ` (${propertyNames.map(this.quoteObject).join(", ")})`;
+        command += ` VALUES (${values}) RETURNING *`;
+        return {
+            command,
+            params: ctx.params,
+        };
+    }
+    update(model, options) {
+        const params = [];
+        const ctx = {
+            params,
+        };
+        let { entity, filters } = options;
+        let command = "UPDATE ";
+        command += this.quoteTable(model);
+        command += " SET ";
+        const propertyNames = Object.keys(entity);
+        propertyNames.forEach((propertyName, index) => {
+            if (index) {
+                command += ", ";
+            }
+            let property = null;
+            if (model) {
+                property = ___namespace.find(model.properties, (e) => (e.columnName || e.code) === propertyName);
+            }
+            if (property && property.type === "json") {
+                params.push(JSON.stringify(entity[propertyName]));
+                command += `${this.quoteObject(propertyName)}=$${params.length}::jsonb`;
+            }
+            else {
+                params.push(entity[propertyName]);
+                command += `${this.quoteObject(propertyName)}=$${params.length}`;
+            }
+        });
+        if (filters && filters.length) {
+            command += " WHERE ";
+            command += buildFiltersQuery(ctx, filters);
+        }
+        command += " RETURNING *";
+        return {
+            command,
+            params: ctx.params,
+        };
+    }
+    delete(model, options) {
+        const params = [];
+        const ctx = {
+            params,
+        };
+        let { filters } = options;
+        let command = "DELETE FROM ";
+        command += this.quoteTable(model);
+        if (filters && filters.length) {
+            command += " WHERE ";
+            command += buildFiltersQuery(ctx, filters);
+        }
+        return {
+            command,
+            params: ctx.params,
+        };
+    }
+}
+function buildFiltersQuery(ctx, filters) {
+    return buildFilterQuery(0, ctx, {
+        operator: "and",
+        filters,
+    });
+}
+function buildFilterQuery(level, ctx, filter) {
+    const { operator } = filter;
+    if (operator === "eq" || operator === "ne" || operator === "gt" ||
+        operator === "gte" || operator === "lt" || operator === "lte") {
+        return buildRelationalFilterQuery(ctx, filter);
+    }
+    else if (operator === "and" || operator === "or") {
+        return buildLogicalFilterQuery(level, ctx, filter);
+    }
+    else if (operator === "null" || operator === "notNull") {
+        return buildUnaryFilterQuery(ctx, filter);
+    }
+    else if (operator === "in" || operator === "notIn") {
+        return buildInFilterQuery(ctx, filter);
+    }
+    else if (operator === "contains") {
+        return buildContainsFilterQuery(ctx, filter);
+    }
+    else if (operator === "notContains") {
+        return buildNotContainsFilterQuery(ctx, filter);
+    }
+    else if (operator === "startsWith") {
+        return buildStartsWithFilterQuery(ctx, filter);
+    }
+    else if (operator === "notStartsWith") {
+        return buildNotStartsWithFilterQuery(ctx, filter);
+    }
+    else if (operator === "endsWith") {
+        return buildEndsWithFilterQuery(ctx, filter);
+    }
+    else if (operator === "notEndsWith") {
+        return buildNotEndsWithFilterQuery(ctx, filter);
+    }
+    else {
+        throw new Error(`Filter operator '${operator}' is not supported.`);
+    }
+}
+function buildLogicalFilterQuery(level, ctx, filter) {
+    let dbOperator;
+    if (filter.operator === "and") {
+        dbOperator = " AND ";
+    }
+    else {
+        dbOperator = " OR ";
+    }
+    let command = filter.filters.map(buildFilterQuery.bind(null, level + 1, ctx))
+        .join(dbOperator);
+    if (level) {
+        return `(${command})`;
+    }
+    return command;
+}
+function buildUnaryFilterQuery(ctx, filter) {
+    let command = this.quoteObject(filter.field);
+    if (filter.operator === "null") {
+        command += " IS NULL";
+    }
+    else {
+        command += " IS NOT NULL";
+    }
+    return command;
+}
+function buildInFilterQuery(ctx, filter) {
+    let command = this.quoteObject(filter.field);
+    if (filter.operator === "in") {
+        command += " = ";
+    }
+    else {
+        command += " <> ";
+    }
+    ctx.params.push(filter.value);
+    command += `ANY($${ctx.params.length}::${filter.itemType || "int"}[])`;
+    return command;
+}
+function buildContainsFilterQuery(ctx, filter) {
+    let command = this.quoteObject(filter.field);
+    command += " LIKE ";
+    ctx.params.push(`%${filter.value}%`);
+    command += "$" + ctx.params.length;
+    return command;
+}
+function buildNotContainsFilterQuery(ctx, filter) {
+    let command = this.quoteObject(filter.field);
+    command += " NOT LIKE ";
+    ctx.params.push(`%${filter.value}%`);
+    command += "$" + ctx.params.length;
+    return command;
+}
+function buildStartsWithFilterQuery(ctx, filter) {
+    let command = this.quoteObject(filter.field);
+    command += " LIKE ";
+    ctx.params.push(`${filter.value}%`);
+    command += "$" + ctx.params.length;
+    return command;
+}
+function buildNotStartsWithFilterQuery(ctx, filter) {
+    let command = this.quoteObject(filter.field);
+    command += " NOT LIKE ";
+    ctx.params.push(`${filter.value}%`);
+    command += "$" + ctx.params.length;
+    return command;
+}
+function buildEndsWithFilterQuery(ctx, filter) {
+    let command = this.quoteObject(filter.field);
+    command += " LIKE ";
+    ctx.params.push(`%${filter.value}`);
+    command += "$" + ctx.params.length;
+    return command;
+}
+function buildNotEndsWithFilterQuery(ctx, filter) {
+    let command = this.quoteObject(filter.field);
+    command += " NOT LIKE ";
+    ctx.params.push(`%${filter.value}`);
+    command += "$" + ctx.params.length;
+    return command;
+}
+function buildRelationalFilterQuery(ctx, filter) {
+    let command = this.quoteObject(filter.field);
+    command += relationalOperatorsMap.get(filter.operator);
+    ctx.params.push(filter.value);
+    command += "$" + ctx.params.length;
+    return command;
+}
+
+class Plugin {
+    #name;
+    constructor(name) {
+        this.#name = name;
+    }
+    getName() {
+        return this.#name;
+    }
+}
+
+function isUndefined(val) {
+    return typeof val === "undefined";
+}
+function isNull(val) {
+    return val === null;
+}
+function isNullOrUndefined(val) {
+    return isNull(val) || isUndefined(val);
+}
+
+function isRelationProperty(property) {
+    return property.type === "relation" || property.type === "relation[]";
+}
+
+// TODO Generate mapper and cache it.
+function mapDbRowToEntity(model, row) {
+    if (!row) {
+        return null;
+    }
+    if (!model.properties || !model.properties.length) {
+        return row;
+    }
+    const result = {};
+    const columnNames = Object.keys(row);
+    columnNames.forEach(columnName => {
+        let isRelationProp = false;
+        let propertyName = columnName;
+        let property = model.properties.find(item => item.columnName === columnName);
+        if (property) {
+            propertyName = property.code;
+        }
+        else {
+            property = model.properties.find(item => item.relation === "one" && item.targetIdColumnName === columnName);
+            if (property) {
+                isRelationProp = true;
+                propertyName = property.code;
+            }
+        }
+        if (isRelationProp) {
+            if (row[propertyName] && !result[propertyName]) {
+                result[propertyName] = row[propertyName];
+            }
+        }
+        else {
+            if (!result[propertyName]) {
+                result[propertyName] = row[columnName];
+            }
+        }
+    });
+    return result;
+}
+function mapEntityToDbRow(model, entity) {
+    if (!entity) {
+        return null;
+    }
+    if (!model.properties || !model.properties.length) {
+        return entity;
+    }
+    const result = {};
+    const propertyNames = Object.keys(entity);
+    propertyNames.forEach(propertyName => {
+        let columnName = propertyName;
+        const property = model.properties.find(item => item.code === propertyName);
+        if (property) {
+            if (!isRelationProperty(property)) {
+                columnName = property.columnName || property.code;
+                result[columnName] = entity[propertyName];
+            }
+        }
+        else {
+            const oneRelationProperty = model.properties.find(item => item.relation === "one" && item.targetIdColumnName === propertyName);
+            if (oneRelationProperty) {
+                result[propertyName] = entity[propertyName];
+            }
+        }
+    });
+    return result;
+}
+
+function mapPropertyNameToColumnName(model, propertyName) {
+    if (!model.properties) {
+        return propertyName;
+    }
+    const property = model.properties.find(item => item.code === propertyName);
+    if (!property) {
+        return propertyName;
+    }
+    if (isRelationProperty(property) && property.relation === "one") {
+        return property.targetIdColumnName;
+    }
+    return property.columnName || property.code;
+}
+
+function convertToDataAccessOrderBy(model, orderByList) {
+    if (!orderByList) {
+        return orderByList;
+    }
+    return orderByList.map(orderBy => {
+        return {
+            field: mapPropertyNameToColumnName(model, orderBy.field),
+            desc: !!orderBy.desc,
+        };
+    });
+}
+async function findEntities(server, dataAccessor, options) {
+    const model = dataAccessor.getModel();
+    const fieldsToSelect = [];
+    const relationPropertiesToSelect = [];
+    if (options.properties) {
+        ___namespace.forEach(options.properties, (propertyCode) => {
+            const property = model.properties.find((e) => e.code === propertyCode);
+            if (!property) {
+                throw new Error(`Collection '${model.namespace}.${model.singularCode}' does not have a property '${propertyCode}'.`);
+            }
+            if (isRelationProperty(property)) {
+                relationPropertiesToSelect.push(property);
+                if (property.relation === "one" && !property.linkTableName) {
+                    if (!property.targetIdColumnName) {
+                        throw new Error(`'targetIdColumnName' should be configured for property '${propertyCode}' of model '${model.namespace}.${model.singularCode}'.`);
+                    }
+                    fieldsToSelect.push(property.targetIdColumnName);
+                }
+            }
+            else {
+                fieldsToSelect.push(property.columnName || property.code);
+            }
+        });
+    }
+    const processedFilters = await replaceFiltersWithFiltersOperator(server, model, options.filters);
+    const findEntityOptions = {
+        filters: processedFilters,
+        orderBy: convertToDataAccessOrderBy(model, options.orderBy),
+        pagination: options.pagination,
+        properties: fieldsToSelect,
+    };
+    const entities = await dataAccessor.find(findEntityOptions);
+    if (!entities.length) {
+        return entities;
+    }
+    const entityIds = entities.map((e) => e.id);
+    if (relationPropertiesToSelect.length) {
+        for (const relationProperty of relationPropertiesToSelect) {
+            const isManyRelation = relationProperty.relation === "many";
+            if (relationProperty.linkTableName) {
+                const targetModel = server.getModel({ singularCode: relationProperty.targetSingularCode });
+                if (!targetModel) {
+                    continue;
+                }
+                if (isManyRelation) {
+                    const relationLinks = await findManyRelationLinksViaLinkTable(server, targetModel, relationProperty, entityIds);
+                    ___namespace.forEach(entities, (entity) => {
+                        entity[relationProperty.code] = ___namespace.filter(relationLinks, (link) => {
+                            return link[relationProperty.selfIdColumnName] == entity["id"];
+                        }).map(link => mapDbRowToEntity(targetModel, link.targetEntity));
+                    });
+                }
+            }
+            else {
+                let relatedEntities;
+                if (isManyRelation) {
+                    relatedEntities = await findManyRelatedEntitiesViaIdPropertyCode(server, model, relationProperty, entityIds);
+                }
+                else {
+                    const targetEntityIds = ___namespace.uniq(___namespace.reject(___namespace.map(entities, (entity) => entity[relationProperty.targetIdColumnName]), isNullOrUndefined));
+                    relatedEntities = await findOneRelatedEntitiesViaIdPropertyCode(server, model, relationProperty, targetEntityIds);
+                }
+                const targetModel = server.getModel({
+                    singularCode: relationProperty.targetSingularCode,
+                });
+                entities.forEach((entity) => {
+                    if (isManyRelation) {
+                        entity[relationProperty.code] = ___namespace.filter(relatedEntities, (relatedEntity) => {
+                            return relatedEntity[relationProperty.selfIdColumnName] == entity.id;
+                        }).map(item => mapDbRowToEntity(targetModel, item));
+                    }
+                    else {
+                        entity[relationProperty.code] = mapDbRowToEntity(targetModel, ___namespace.find(relatedEntities, (relatedEntity) => {
+                            // TODO: id property code should be configurable.
+                            return relatedEntity["id"] == entity[relationProperty.targetIdColumnName];
+                        }));
+                    }
+                });
+            }
+        }
+    }
+    return entities.map(item => mapDbRowToEntity(model, item));
+}
+async function findEntity(server, dataAccessor, options) {
+    const entities = await findEntities(server, dataAccessor, options);
+    return ___namespace.first(entities);
+}
+async function replaceFiltersWithFiltersOperator(server, model, filters) {
+    if (!filters || !filters.length) {
+        return [];
+    }
+    const replacedFilters = [];
+    for (const filter of filters) {
+        const { operator } = filter;
+        if (operator === "and" || operator === "or") {
+            filter.filters = await replaceFiltersWithFiltersOperator(server, model, filter.filters);
+            replacedFilters.push(filter);
+        }
+        else if (operator === "exists" || operator === "notExists") {
+            const relationProperty = ___namespace.find(model.properties, (property) => property.code === filter.field);
+            if (!relationProperty) {
+                throw new Error(`Invalid filters. Property '${filter.field}' was not found in model '${model.namespace}.${model.singularCode}'`);
+            }
+            if (!isRelationProperty(relationProperty)) {
+                throw new Error(`Invalid filters. Filter with 'existence' operator on property '${filter.field}' is not allowed. You can only use it on an relation property.`);
+            }
+            const relatedEntityFilters = filter.filters;
+            if (!relatedEntityFilters || !relatedEntityFilters.length) {
+                throw new Error(`Invalid filters. 'filters' must be provided on filter with 'existence' operator.`);
+            }
+            if (relationProperty.relation === "one") {
+                // Optimize when filtering by id of related entity
+                if (relatedEntityFilters.length === 1) {
+                    const relatedEntityIdFilter = relatedEntityFilters[0];
+                    if ((relatedEntityIdFilter.operator === "eq" ||
+                        relatedEntityIdFilter.operator === "in") &&
+                        relatedEntityIdFilter.field === "id") {
+                        let replacedOperator;
+                        if (operator === "exists") {
+                            replacedOperator = relatedEntityIdFilter.operator;
+                        }
+                        else {
+                            if (relatedEntityIdFilter.operator === "eq") {
+                                replacedOperator = "ne";
+                            }
+                            else {
+                                replacedOperator = "notIn";
+                            }
+                        }
+                        replacedFilters.push({
+                            field: relationProperty.targetIdColumnName,
+                            operator: replacedOperator,
+                            value: relatedEntityIdFilter.value,
+                        });
+                        continue;
+                    }
+                }
+                const dataAccessor = server.getDataAccessor({
+                    singularCode: relationProperty.targetSingularCode,
+                });
+                const entities = await dataAccessor.find({
+                    filters: filter.filters,
+                    properties: ["id"],
+                });
+                const entityIds = ___namespace.map(entities, (entity) => entity["id"]);
+                replacedFilters.push({
+                    field: relationProperty.targetIdColumnName,
+                    operator: operator === "exists" ? "in" : "notIn",
+                    value: entityIds,
+                });
+            }
+            else if (!relationProperty.linkTableName) {
+                // many relation without link table.
+                if (!relationProperty.selfIdColumnName) {
+                    throw new Error(`Invalid filters. 'selfIdColumnName' of property '${relationProperty.code}' was not configured`);
+                }
+                const targetEntityDataAccessor = server.getDataAccessor({
+                    singularCode: relationProperty.targetSingularCode,
+                });
+                const targetEntities = await targetEntityDataAccessor.find({
+                    filters: filter.filters,
+                    properties: [relationProperty.selfIdColumnName],
+                });
+                const selfEntityIds = ___namespace.map(targetEntities, (entity) => entity[relationProperty.selfIdColumnName]);
+                replacedFilters.push({
+                    field: "id",
+                    operator: operator === "exists" ? "in" : "notIn",
+                    value: selfEntityIds,
+                });
+            }
+            else {
+                // many relation with link table
+                if (!relationProperty.selfIdColumnName) {
+                    throw new Error(`Invalid filters. 'selfIdColumnName' of property '${relationProperty.code}' was not configured`);
+                }
+                if (!relationProperty.targetIdColumnName) {
+                    throw new Error(`Invalid filters. 'targetIdColumnName' of property '${relationProperty.code}' was not configured`);
+                }
+                // 1. find target entities
+                // 2. find links
+                // 3. convert to 'in' filter
+                const targetEntityDataAccessor = server.getDataAccessor({
+                    singularCode: relationProperty.targetSingularCode,
+                });
+                const targetEntities = await targetEntityDataAccessor.find({
+                    filters: filter.filters,
+                    properties: ['id'],
+                });
+                const targetEntityIds = ___namespace.map(targetEntities, (entity) => entity['id']);
+                const command = `SELECT * FROM ${server.queryBuilder.quoteTable({ schema: relationProperty.linkSchema, tableName: relationProperty.linkTableName })} WHERE ${server.queryBuilder.quoteObject(relationProperty.targetIdColumnName)} = ANY($1::int[])`;
+                const params = [targetEntityIds];
+                const links = await server.queryDatabaseObject(command, params);
+                const selfEntityIds = links.map(link => link[relationProperty.selfIdColumnName]);
+                replacedFilters.push({
+                    field: "id",
+                    operator: operator === "exists" ? "in" : "notIn",
+                    value: selfEntityIds,
+                });
+            }
+        }
+        else {
+            replacedFilters.push(filter);
+        }
+    }
+    return replacedFilters;
+}
+async function findManyRelationLinksViaLinkTable(server, targetModel, relationProperty, entityIds) {
+    const command = `SELECT * FROM ${server.queryBuilder.quoteTable({ schema: relationProperty.linkSchema, tableName: relationProperty.linkTableName })} WHERE ${server.queryBuilder.quoteObject(relationProperty.selfIdColumnName)} = ANY($1::int[])`;
+    const params = [entityIds];
+    const links = await server.queryDatabaseObject(command, params);
+    const targetEntityIds = links.map(link => link[relationProperty.targetIdColumnName]);
+    const findEntityOptions = {
+        filters: [
+            {
+                field: "id",
+                operator: "in",
+                value: targetEntityIds,
+            },
+        ],
+    };
+    const dataAccessor = server.getDataAccessor({
+        namespace: targetModel.namespace,
+        singularCode: targetModel.singularCode,
+    });
+    const targetEntities = await dataAccessor.find(findEntityOptions);
+    ___namespace.forEach(links, (link) => {
+        link.targetEntity = ___namespace.find(targetEntities, (e) => e["id"] == link[relationProperty.targetIdColumnName]);
+    });
+    return links;
+}
+function findManyRelatedEntitiesViaIdPropertyCode(server, model, relationProperty, entityIds) {
+    const findEntityOptions = {
+        filters: [
+            {
+                field: relationProperty.selfIdColumnName,
+                operator: "in",
+                value: entityIds,
+            },
+        ],
+    };
+    const dataAccessor = server.getDataAccessor({
+        singularCode: relationProperty.targetSingularCode,
+    });
+    return dataAccessor.find(findEntityOptions);
+}
+function findOneRelatedEntitiesViaIdPropertyCode(server, model, relationProperty, targetEntityIds) {
+    const findEntityOptions = {
+        filters: [
+            {
+                field: "id",
+                operator: "in",
+                value: targetEntityIds,
+            },
+        ],
+    };
+    const dataAccessor = server.getDataAccessor({
+        singularCode: relationProperty.targetSingularCode,
+    });
+    return dataAccessor.find(findEntityOptions);
+}
+async function createEntity(server, dataAccessor, options) {
+    const model = dataAccessor.getModel();
+    const { entity } = options;
+    const oneRelationPropertiesToCreate = [];
+    const manyRelationPropertiesToCreate = [];
+    ___namespace.keys(entity).forEach((propertyCode) => {
+        const property = model.properties.find((e) => e.code === propertyCode);
+        if (!property) {
+            // Unknown property
+            return;
+        }
+        if (isRelationProperty(property)) {
+            if (property.relation === "many") {
+                manyRelationPropertiesToCreate.push(property);
+            }
+            else {
+                oneRelationPropertiesToCreate.push(property);
+            }
+        }
+    });
+    const row = mapEntityToDbRow(model, entity);
+    // save one-relation properties
+    for (const property of oneRelationPropertiesToCreate) {
+        const fieldValue = entity[property.code];
+        if (___namespace.isObject(fieldValue)) {
+            if (!fieldValue["id"]) {
+                const targetDataAccessor = server.getDataAccessor({
+                    singularCode: property.targetSingularCode,
+                });
+                const targetEntity = fieldValue;
+                const newTargetEntity = await createEntity(server, targetDataAccessor, {
+                    entity: targetEntity,
+                });
+                row[property.targetIdColumnName] = newTargetEntity["id"];
+            }
+            else {
+                row[property.targetIdColumnName] = fieldValue["id"];
+            }
+        }
+        else {
+            // fieldValue is id;
+            row[property.targetIdColumnName] = fieldValue;
+        }
+    }
+    const newRow = await dataAccessor.create(row);
+    const newEntity = mapDbRowToEntity(model, newRow);
+    // save many-relation properties
+    for (const property of manyRelationPropertiesToCreate) {
+        newEntity[property.code] = [];
+        const targetDataAccessor = server.getDataAccessor({
+            singularCode: property.targetSingularCode,
+        });
+        const relatedEntitiesToBeSaved = entity[property.code];
+        if (!___namespace.isArray(relatedEntitiesToBeSaved)) {
+            throw new Error(`Value of field '${property.code}' should be an array.`);
+        }
+        for (const relatedEntityToBeSaved of relatedEntitiesToBeSaved) {
+            let relatedEntityId;
+            if (___namespace.isObject(relatedEntityToBeSaved)) {
+                relatedEntityId = relatedEntityToBeSaved["id"];
+                if (!relatedEntityId) {
+                    // related entity is to be created
+                    const targetEntity = relatedEntityToBeSaved;
+                    if (!property.linkTableName) {
+                        targetEntity[property.selfIdColumnName] = newEntity.id;
+                    }
+                    const newTargetEntity = await createEntity(server, targetDataAccessor, {
+                        entity: targetEntity,
+                    });
+                    if (property.linkTableName) {
+                        const command = `INSERT INTO ${server.queryBuilder.quoteTable({ schema: property.linkSchema, tableName: property.linkTableName })} (${server.queryBuilder.quoteObject(property.selfIdColumnName)}, ${property.targetIdColumnName}) VALUES ($1, $2) ON CONFLICT DO NOTHING;`;
+                        const params = [newEntity.id, newTargetEntity.id];
+                        await server.queryDatabaseObject(command, params);
+                    }
+                    newEntity[property.code].push(newTargetEntity);
+                }
+                else {
+                    // related entity is existed
+                    const targetEntity = await targetDataAccessor.findById(relatedEntityId);
+                    if (!targetEntity) {
+                        throw new Error(`Entity with id '${relatedEntityId}' in field '${property.code}' is not exists.`);
+                    }
+                    if (property.linkTableName) {
+                        const command = `INSERT INTO ${server.queryBuilder.quoteTable({ schema: property.linkSchema, tableName: property.linkTableName })} (${server.queryBuilder.quoteObject(property.selfIdColumnName)}, ${property.targetIdColumnName}) VALUES ($1, $2) ON CONFLICT DO NOTHING;`;
+                        const params = [newEntity.id, relatedEntityId];
+                        await server.queryDatabaseObject(command, params);
+                    }
+                    else {
+                        await targetDataAccessor.updateById(targetEntity.id, { [property.selfIdColumnName]: newEntity.id });
+                        targetEntity[property.selfIdColumnName] = newEntity.id;
+                    }
+                    newEntity[property.code].push(targetEntity);
+                }
+            }
+            else {
+                // fieldValue is id
+                relatedEntityId = relatedEntityToBeSaved;
+                const targetEntity = await targetDataAccessor.findById(relatedEntityId);
+                if (!targetEntity) {
+                    throw new Error(`Entity with id '${relatedEntityId}' in field '${property.code}' is not exists.`);
+                }
+                if (property.linkTableName) {
+                    const command = `INSERT INTO ${server.queryBuilder.quoteTable({ schema: property.linkSchema, tableName: property.linkTableName })} (${server.queryBuilder.quoteObject(property.selfIdColumnName)}, ${property.targetIdColumnName}) VALUES ($1, $2) ON CONFLICT DO NOTHING;`;
+                    const params = [newEntity.id, relatedEntityId];
+                    await server.queryDatabaseObject(command, params);
+                }
+                else {
+                    await targetDataAccessor.updateById(targetEntity.id, { [property.selfIdColumnName]: newEntity.id });
+                    targetEntity[property.selfIdColumnName] = newEntity.id;
+                }
+                newEntity[property.code].push(targetEntity);
+            }
+        }
+    }
+    return newEntity;
+}
+async function updateEntityById(server, dataAccessor, options) {
+    const model = dataAccessor.getModel();
+    const { id, entity, changes } = options;
+    const oneRelationPropertiesToUpdate = [];
+    const manyRelationPropertiesToUpdate = [];
+    ___namespace.keys(changes).forEach((propertyCode) => {
+        const property = model.properties.find((e) => e.code === propertyCode);
+        if (!property) {
+            // Unknown property
+            return;
+        }
+        if (isRelationProperty(property)) {
+            if (property.relation === "many") {
+                manyRelationPropertiesToUpdate.push(property);
+            }
+            else {
+                oneRelationPropertiesToUpdate.push(property);
+            }
+        }
+    });
+    const row = mapEntityToDbRow(model, changes);
+    oneRelationPropertiesToUpdate.forEach(property => {
+        const fieldValue = changes[property.code];
+        if (___namespace.isObject(fieldValue)) {
+            row[property.targetIdColumnName] = fieldValue["id"];
+        }
+        else {
+            row[property.targetIdColumnName] = fieldValue;
+        }
+    });
+    let updatedRow = row;
+    if (Object.keys(row).length) {
+        updatedRow = await dataAccessor.updateById(id, row);
+    }
+    const updatedEntity = Object.assign({}, entity, updatedRow);
+    // save many-relation properties
+    for (const property of manyRelationPropertiesToUpdate) {
+        const relatedEntities = [];
+        const targetDataAccessor = server.getDataAccessor({
+            singularCode: property.targetSingularCode,
+        });
+        const relatedEntitiesToBeSaved = changes[property.code];
+        if (!___namespace.isArray(relatedEntitiesToBeSaved)) {
+            throw new Error(`Value of field '${property.code}' should be an array.`);
+        }
+        if (property.linkTableName) {
+            // TODO: should support removing relation
+            await server.queryDatabaseObject(`DELETE FROM ${server.queryBuilder.quoteTable({ schema: property.linkSchema, tableName: property.linkTableName })} WHERE ${server.queryBuilder.quoteObject(property.selfIdColumnName)} = $1`, [id]);
+        }
+        for (const relatedEntityToBeSaved of relatedEntitiesToBeSaved) {
+            let relatedEntityId;
+            if (___namespace.isObject(relatedEntityToBeSaved)) {
+                relatedEntityId = relatedEntityToBeSaved["id"];
+                if (!relatedEntityId) {
+                    // related entity is to be created
+                    const targetEntity = relatedEntityToBeSaved;
+                    if (!property.linkTableName) {
+                        targetEntity[property.selfIdColumnName] = id;
+                    }
+                    const newTargetEntity = await createEntity(server, targetDataAccessor, {
+                        entity: targetEntity,
+                    });
+                    if (property.linkTableName) {
+                        const command = `INSERT INTO ${server.queryBuilder.quoteTable({ schema: property.linkSchema, tableName: property.linkTableName })} (${server.queryBuilder.quoteObject(property.selfIdColumnName)}, ${property.targetIdColumnName}) VALUES ($1, $2) ON CONFLICT DO NOTHING;`;
+                        const params = [id, newTargetEntity.id];
+                        await server.queryDatabaseObject(command, params);
+                    }
+                    relatedEntities.push(newTargetEntity);
+                }
+                else {
+                    // related entity is existed
+                    const targetEntity = await targetDataAccessor.findById(relatedEntityId);
+                    if (!targetEntity) {
+                        throw new Error(`Entity with id '${relatedEntityId}' in field '${property.code}' is not exists.`);
+                    }
+                    if (property.linkTableName) {
+                        const command = `INSERT INTO ${server.queryBuilder.quoteTable({ schema: property.linkSchema, tableName: property.linkTableName })} (${server.queryBuilder.quoteObject(property.selfIdColumnName)}, ${property.targetIdColumnName}) VALUES ($1, $2) ON CONFLICT DO NOTHING;`;
+                        const params = [id, relatedEntityId];
+                        await server.queryDatabaseObject(command, params);
+                    }
+                    else {
+                        await targetDataAccessor.updateById(targetEntity.id, { [property.selfIdColumnName]: id });
+                        targetEntity[property.selfIdColumnName] = id;
+                    }
+                    relatedEntities.push(targetEntity);
+                }
+            }
+            else {
+                // fieldValue is id
+                relatedEntityId = relatedEntityToBeSaved;
+                const targetEntity = await targetDataAccessor.findById(relatedEntityId);
+                if (!targetEntity) {
+                    throw new Error(`Entity with id '${relatedEntityId}' in field '${property.code}' is not exists.`);
+                }
+                if (property.linkTableName) {
+                    const command = `INSERT INTO ${server.queryBuilder.quoteTable({ schema: property.linkSchema, tableName: property.linkTableName })} (${server.queryBuilder.quoteObject(property.selfIdColumnName)}, ${property.targetIdColumnName}) VALUES ($1, $2) ON CONFLICT DO NOTHING;`;
+                    const params = [id, relatedEntityId];
+                    await server.queryDatabaseObject(command, params);
+                }
+                else {
+                    await targetDataAccessor.updateById(targetEntity.id, { [property.selfIdColumnName]: id });
+                    targetEntity[property.selfIdColumnName] = id;
+                }
+                relatedEntities.push(targetEntity);
+            }
+        }
+        updatedEntity[property.code] = relatedEntities;
+    }
+    return updatedEntity;
+}
+
+const code$l = "listMetaModels";
+async function handler$g(plugin, ctx, options) {
+    const { applicationConfig } = ctx;
+    ctx.output = { list: applicationConfig.models };
+}
+
+var listMetaModels = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  code: code$l,
+  handler: handler$g
+});
+
+const code$k = "getMetaModelDetail";
+async function handler$f(plugin, ctx, options) {
+    const { server, input } = ctx;
+    const model = server.getModel(input);
+    ctx.output = model;
+}
+
+var getMetaModelDetail = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  code: code$k,
+  handler: handler$f
+});
+
+/**
+ * Meta manager plugin
+ */
+const code$j = "metaManager";
+const description$4 = "metaManager";
+const extendingAbilities$4 = [];
+const configurableTargets$4 = [];
+const configurations$4 = [];
+let _plugin$4;
+async function initPlugin$4(plugin, server) {
+    _plugin$4 = plugin;
+}
+async function registerHttpHandlers$4(server) {
+    server.registerHttpHandler(_plugin$4, listMetaModels);
+    server.registerHttpHandler(_plugin$4, getMetaModelDetail);
+}
+async function registerEventHandlers$3(server) {
+    server.registerEventHandler("entity.create", handleEntityCreateEvent.bind(null, server));
+    server.registerEventHandler("entity.update", handleEntityUpdateEvent.bind(null, server));
+    server.registerEventHandler("entity.delete", handleEntityDeleteEvent.bind(null, server));
+}
+async function handleEntityCreateEvent(server, sender, payload) {
+    if (sender === _plugin$4) {
+        return;
+    }
+    if (payload.namespace === "meta" && payload.modelSingularCode === "model") {
+        return;
+    }
+}
+async function handleEntityUpdateEvent(server, sender, payload) {
+    if (sender === _plugin$4) {
+        return;
+    }
+    if (payload.namespace === "meta" && payload.modelSingularCode === "model") {
+        return;
+    }
+}
+async function handleEntityDeleteEvent(server, sender, payload) {
+    if (sender === _plugin$4) {
+        return;
+    }
+    if (payload.namespace !== "meta") {
+        return;
+    }
+    const { queryBuilder } = server;
+    if (payload.modelSingularCode === "model") {
+        const deletedModel = payload.before;
+        await server.queryDatabaseObject(`DROP TABLE ${queryBuilder.quoteTable(deletedModel)}`, []);
+    }
+    else if (payload.modelSingularCode === "property") {
+        const deletedProperty = payload.before;
+        let columnNameToDrop = deletedProperty.columnName || deletedProperty.code;
+        if (isRelationProperty(deletedProperty)) {
+            if (deletedProperty.relation === "one") {
+                columnNameToDrop = deletedProperty.targetIdColumnName || "";
+            }
+            else {
+                // many relation
+                return;
+            }
+        }
+        const dataAccessor = server.getDataAccessor({
+            namespace: "meta",
+            singularCode: "model",
+        });
+        const model = await dataAccessor.findById(deletedProperty.modelId);
+        if (model) {
+            await server.queryDatabaseObject(`ALTER TABLE ${queryBuilder.quoteTable(model)} DROP COLUMN ${queryBuilder.quoteObject(columnNameToDrop)}`, []);
+        }
+    }
+}
+async function configureModels$3(server, applicationConfig) {
+    try {
+        const models = await listCollections(server, applicationConfig);
+        applicationConfig.models.push(...models);
+    }
+    catch (ex) {
+        console.warn("Failed to loading existing meta of models.", ex.message);
+    }
+}
+function listCollections(server, applicationConfig) {
+    const dataAccessor = server.getDataAccessor({
+        namespace: "meta",
+        singularCode: "model",
+    });
+    const model = dataAccessor.getModel();
+    return findEntities(server, dataAccessor, {
+        properties: model.properties.map((item) => item.code),
+    });
+}
+async function onApplicationLoaded$5(server, applicationConfig) {
+    console.log("metaManager.onApplicationLoaded");
+    await syncDatabaseSchema(server, applicationConfig);
+}
+async function syncDatabaseSchema(server, applicationConfig) {
+    console.log("Synchronizing database schema...");
+    const sqlQueryTableInformations = `SELECT table_schema, table_name FROM information_schema.tables`;
+    const tablesInDb = await server.queryDatabaseObject(sqlQueryTableInformations);
+    const { queryBuilder } = server;
+    for (const model of applicationConfig.models) {
+        console.debug(`Checking data table for '${model.namespace}.${model.singularCode}'...`);
+        const expectedTableSchema = model.schema || server.databaseConfig.dbDefaultSchema;
+        const expectedTableName = model.tableName;
+        const tableInDb = ___namespace.find(tablesInDb, { table_schema: expectedTableSchema, table_name: expectedTableName });
+        if (!tableInDb) {
+            await server.queryDatabaseObject(`CREATE TABLE IF NOT EXISTS ${queryBuilder.quoteTable(model)} ()`, []);
+        }
+    }
+    const sqlQueryColumnInformations = `SELECT table_schema, table_name, column_name, data_type, udt_name, is_nullable, column_default, character_maximum_length, numeric_precision, numeric_scale
+  FROM information_schema.columns;`;
+    const columnsInDb = await server.queryDatabaseObject(sqlQueryColumnInformations, []);
+    for (const model of applicationConfig.models) {
+        console.debug(`Checking data columns for '${model.namespace}.${model.singularCode}'...`);
+        for (const property of model.properties) {
+            let columnDDL;
+            if (isRelationProperty(property)) {
+                if (property.relation === "one") {
+                    const targetModel = applicationConfig.models.find(item => item.singularCode === property.targetSingularCode);
+                    if (!targetModel) {
+                        console.warn(`Cannot find target model with singular code "${property.targetSingularCode}".`);
+                    }
+                    const columnInDb = ___namespace.find(columnsInDb, {
+                        table_schema: model.schema || "public",
+                        table_name: model.tableName,
+                        column_name: property.targetIdColumnName,
+                    });
+                    if (!columnInDb) {
+                        columnDDL = generateCreateColumnDDL(queryBuilder, {
+                            schema: model.schema,
+                            tableName: model.tableName,
+                            name: property.targetIdColumnName,
+                            type: "integer",
+                            autoIncrement: false,
+                            notNull: property.required,
+                        });
+                    }
+                }
+                else if (property.relation === "many") {
+                    if (property.linkTableName) {
+                        const tableInDb = ___namespace.find(tablesInDb, { table_schema: property.linkSchema || server.databaseConfig.dbDefaultSchema, table_name: property.linkTableName });
+                        if (!tableInDb) {
+                            columnDDL = generateLinkTableDDL(queryBuilder, {
+                                linkSchema: property.linkSchema,
+                                linkTableName: property.linkTableName,
+                                targetIdColumnName: property.targetIdColumnName,
+                                selfIdColumnName: property.selfIdColumnName,
+                            });
+                        }
+                    }
+                    else {
+                        const targetModel = applicationConfig.models.find(item => item.singularCode === property.targetSingularCode);
+                        if (!targetModel) {
+                            console.warn(`Cannot find target model with singular code "${property.targetSingularCode}".`);
+                            continue;
+                        }
+                        const columnInDb = ___namespace.find(columnsInDb, {
+                            table_schema: targetModel.schema || "public",
+                            table_name: targetModel.tableName,
+                            column_name: property.selfIdColumnName,
+                        });
+                        if (!columnInDb) {
+                            columnDDL = generateCreateColumnDDL(queryBuilder, {
+                                schema: targetModel.schema,
+                                tableName: targetModel.tableName,
+                                name: property.selfIdColumnName || "",
+                                type: "integer",
+                                autoIncrement: false,
+                                notNull: property.required,
+                            });
+                        }
+                    }
+                }
+                else {
+                    continue;
+                }
+                if (columnDDL) {
+                    await server.tryQueryDatabaseObject(columnDDL);
+                }
+            }
+            else {
+                const columnName = property.columnName || property.code;
+                const columnInDb = ___namespace.find(columnsInDb, {
+                    table_schema: model.schema || "public",
+                    table_name: model.tableName,
+                    column_name: columnName,
+                });
+                if (!columnInDb) {
+                    // create column if not exists
+                    columnDDL = generateCreateColumnDDL(queryBuilder, {
+                        schema: model.schema,
+                        tableName: model.tableName,
+                        name: columnName,
+                        type: property.type,
+                        autoIncrement: property.autoIncrement,
+                        notNull: property.required,
+                        defaultValue: property.defaultValue,
+                    });
+                    await server.tryQueryDatabaseObject(columnDDL);
+                }
+                else {
+                    const expectedColumnType = pgPropertyTypeColumnMap[property.type];
+                    if (columnInDb.udt_name !== expectedColumnType) {
+                        const sqlAlterColumnType = `alter table ${queryBuilder.quoteTable(model)} alter column ${queryBuilder.quoteObject(columnName)} type ${expectedColumnType}`;
+                        await server.tryQueryDatabaseObject(sqlAlterColumnType);
+                    }
+                    if (property.defaultValue) {
+                        if (!columnInDb.column_default) {
+                            const sqlSetColumnDefault = `alter table ${queryBuilder.quoteTable(model)} alter column ${queryBuilder.quoteObject(columnName)} set default ${property.defaultValue}`;
+                            await server.tryQueryDatabaseObject(sqlSetColumnDefault);
+                        }
+                    }
+                    else {
+                        if (columnInDb.column_default && !property.autoIncrement) {
+                            const sqlDropColumnDefault = `alter table ${queryBuilder.quoteTable(model)} alter column ${queryBuilder.quoteObject(columnName)} drop default`;
+                            await server.tryQueryDatabaseObject(sqlDropColumnDefault);
+                        }
+                    }
+                    if (property.required) {
+                        if (columnInDb.is_nullable === "YES") {
+                            const sqlSetColumnNotNull = `alter table ${queryBuilder.quoteTable(model)} alter column ${queryBuilder.quoteObject(columnName)} set not null`;
+                            await server.tryQueryDatabaseObject(sqlSetColumnNotNull);
+                        }
+                    }
+                    else {
+                        if (columnInDb.is_nullable === "NO") {
+                            const sqlDropColumnNotNull = `alter table ${queryBuilder.quoteTable(model)} alter column ${queryBuilder.quoteObject(columnName)} drop not null`;
+                            await server.tryQueryDatabaseObject(sqlDropColumnNotNull);
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+function generateCreateColumnDDL(queryBuilder, options) {
+    let columnDDL = `ALTER TABLE ${queryBuilder.quoteTable(options)} ADD`;
+    columnDDL += ` ${queryBuilder.quoteObject(options.name)}`;
+    if (options.type === "integer" && options.autoIncrement) {
+        columnDDL += ` serial`;
+    }
+    else {
+        const columnType = pgPropertyTypeColumnMap[options.type];
+        if (!columnType) {
+            console.log('options', options);
+            throw new Error(`Property type "${options.type}" is not supported.`);
+        }
+        columnDDL += ` ${columnType}`;
+    }
+    if (options.notNull) {
+        columnDDL += " NOT NULL";
+    }
+    if (options.defaultValue) {
+        columnDDL += ` DEFAULT ${options.defaultValue}`;
+    }
+    return columnDDL;
+}
+function generateLinkTableDDL(queryBuilder, options) {
+    let columnDDL = `CREATE TABLE ${queryBuilder.quoteTable({
+        schema: options.linkSchema,
+        tableName: options.linkTableName,
+    })} (`;
+    columnDDL += `id serial not null,`;
+    columnDDL += `${queryBuilder.quoteObject(options.selfIdColumnName)} integer not null,`;
+    columnDDL += `${queryBuilder.quoteObject(options.targetIdColumnName)} integer not null)`;
+    return columnDDL;
+}
+const pgPropertyTypeColumnMap = {
+    integer: "int4",
+    long: "int8",
+    float: "float4",
+    double: "float8",
+    decimal: "decimal",
+    text: "text",
+    boolean: "bool",
+    date: "date",
+    datetime: "timestamptz",
+    json: "jsonb",
+    option: "text",
+};
+
+var metaManager = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  code: code$j,
+  description: description$4,
+  extendingAbilities: extendingAbilities$4,
+  configurableTargets: configurableTargets$4,
+  configurations: configurations$4,
+  initPlugin: initPlugin$4,
+  registerHttpHandlers: registerHttpHandlers$4,
+  registerEventHandlers: registerEventHandlers$3,
+  configureModels: configureModels$3,
+  onApplicationLoaded: onApplicationLoaded$5
+});
+
+function mergeInput(defaultInput, input, fixedInput) {
+    return ___namespace.mergeWith({}, defaultInput, input, fixedInput, doNotMergeArray);
+}
+function doNotMergeArray(objValue, srcValue) {
+    if (___namespace.isArray(srcValue)) {
+        return srcValue;
+    }
+}
+
+async function runCollectionEntityHttpHandler(ctx, options, code, handleDataAccess) {
+    const { server, input } = ctx;
+    const { defaultInput, fixedInput } = options;
+    console.debug(`Running ${code} handler...`);
+    console.debug(`defaultInput: ${JSON.stringify(defaultInput)}`);
+    const mergedInput = mergeInput(defaultInput, input, fixedInput);
+    console.debug(`fixedInput: ${JSON.stringify(fixedInput)}`);
+    console.debug(`mergedInput: ${JSON.stringify(mergedInput)}`);
+    const dataAccessor = server.getDataAccessor(options);
+    const result = handleDataAccess(dataAccessor, mergedInput);
+    if (result instanceof Promise) {
+        ctx.output = await result;
+    }
+    else {
+        ctx.output = result;
+    }
+}
+
+function removeFiltersWithNullValue(filters) {
+    const result = [];
+    if (!filters) {
+        return result;
+    }
+    for (const filter of filters) {
+        const { operator } = filter;
+        switch (operator) {
+            case "null":
+            case "notNull":
+                result.push(filter);
+                break;
+            case "exists":
+            case "notExists":
+            case "and":
+            case "or":
+                const transformedFilter = transformFilterWithSubFilters(filter);
+                if (transformedFilter !== null) {
+                    result.push(transformedFilter);
+                }
+                break;
+            default:
+                if (!isNullOrUndefined(filter.value)) {
+                    result.push(filter);
+                }
+        }
+    }
+    return result;
+}
+function transformFilterWithSubFilters(filter) {
+    const subFilters = removeFiltersWithNullValue(filter.filters);
+    if (!subFilters.length) {
+        return null;
+    }
+    filter.filters = subFilters;
+    return filter;
+}
+
+const code$i = "findCollectionEntities";
+async function handler$e(plugin, ctx, options) {
+    await runCollectionEntityHttpHandler(ctx, options, code$i, async (dataAccessor, input) => {
+        input.filters = removeFiltersWithNullValue(input.filters);
+        const entities = await findEntities(ctx.server, dataAccessor, input);
+        const result = { list: entities };
+        if (input.pagination && !input.pagination.withoutTotal) {
+            // TOOD: impl count entities by using entity manager, because DataAccessor does not support 'exists' and 'notExists' filter.
+            const countResult = await dataAccessor.count(input);
+            result.total = countResult.count;
+        }
+        return result;
+    });
+}
+
+var findCollectionEntitiesHttpHandler = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  code: code$i,
+  handler: handler$e
+});
+
+const code$h = "findCollectionEntityById";
+async function handler$d(plugin, ctx, options) {
+    console.debug(`Running ${code$h} handler...`);
+    const { server, input } = ctx;
+    const { id } = input;
+    const dataAccessor = server.getDataAccessor(options);
+    const user = await findEntity(ctx.server, dataAccessor, {
+        filters: [
+            {
+                operator: "eq",
+                field: "id",
+                value: id,
+            }
+        ],
+    });
+    if (!user) {
+        throw new Error(`${options.namespace}.${options.singularCode} with id "${id}" was not found.`);
+    }
+    ctx.output = user;
+}
+
+var findCollectionEntityById = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  code: code$h,
+  handler: handler$d
+});
+
+const code$g = "countCollectionEntities";
+async function handler$c(plugin, ctx, options) {
+    await runCollectionEntityHttpHandler(ctx, options, code$g, (dataAccessor, input) => {
+        input.filters = removeFiltersWithNullValue(input.filters);
+        return dataAccessor.count(input);
+    });
+}
+
+var countCollectionEntities = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  code: code$g,
+  handler: handler$c
+});
+
+const code$f = "createCollectionEntity";
+async function handler$b(plugin, ctx, options) {
+    const { server, input } = ctx;
+    const { defaultInput, fixedInput } = options;
+    console.debug(`Running ${code$f} handler...`);
+    console.debug(`defaultInput: ${JSON.stringify(defaultInput)}`);
+    const mergedInput = mergeInput(defaultInput, input, fixedInput);
+    console.debug(`fixedInput: ${JSON.stringify(fixedInput)}`);
+    console.debug(`mergedInput: ${JSON.stringify(mergedInput)}`);
+    const userId = ctx.routerContext.state?.userId;
+    if (userId) {
+        input.createdBy = userId;
+    }
+    const dataAccessor = server.getDataAccessor(options);
+    const output = await createEntity(server, dataAccessor, {
+        entity: input,
+    });
+    ctx.output = output;
+    server.emitEvent("entity.create", plugin, {
+        namespace: options.namespace,
+        modelSingularCode: options.singularCode,
+        after: output,
+    });
+}
+
+var createCollectionEntity = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  code: code$f,
+  handler: handler$b
+});
+
+const code$e = "createCollectionEntitiesBatch";
+async function handler$a(plugin, ctx, options) {
+    const { server, input } = ctx;
+    const { defaultInput, fixedInput } = options;
+    console.debug(`Running ${code$e} handler...`);
+    const { entities } = input;
+    if (!_.isArray(entities)) {
+        throw new Error("input.entities should be an array.");
+    }
+    console.debug(`defaultInput: ${JSON.stringify(defaultInput)}`);
+    console.debug(`fixedInput: ${JSON.stringify(fixedInput)}`);
+    const output = [];
+    for (const entity of entities) {
+        const mergedEntity = mergeInput(defaultInput?.entity || {}, entity, fixedInput?.entity);
+        console.debug(`mergedEntity: ${JSON.stringify(mergedEntity)}`);
+        const userId = ctx.routerContext.state?.userId;
+        if (userId) {
+            mergedEntity.createdBy = userId;
+        }
+        const dataAccessor = server.getDataAccessor(options);
+        const newEntity = await createEntity(server, dataAccessor, {
+            entity: mergedEntity,
+        });
+        server.emitEvent("entity.create", plugin, {
+            namespace: options.namespace,
+            modelSingularCode: options.singularCode,
+            after: newEntity,
+        });
+        output.push(newEntity);
+    }
+    ctx.output = output;
+}
+
+var createCollectionEntitiesBatch = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  code: code$e,
+  handler: handler$a
+});
+
+function getEntityPartChanges(before, after) {
+    if (!before) {
+        throw new Error("Argument 'before' can not be null.");
+    }
+    if (!after) {
+        throw new Error("Argument 'after' can not be null.");
+    }
+    let changed = null;
+    for (const key in after) {
+        if (after[key] != before[key]) {
+            if (changed) {
+                changed[key] = after[key];
+            }
+            else {
+                changed = { [key]: after[key] };
+            }
+        }
+    }
+    return changed;
+}
+
+const code$d = "updateCollectionEntityById";
+async function handler$9(plugin, ctx, options) {
+    const { server, input } = ctx;
+    const { defaultInput, fixedInput } = options;
+    console.debug(`Running ${code$d} handler...`);
+    console.debug(`defaultInput: ${JSON.stringify(defaultInput)}`);
+    const mergedInput = mergeInput(defaultInput, input, fixedInput);
+    console.debug(`fixedInput: ${JSON.stringify(fixedInput)}`);
+    console.debug(`mergedInput: ${JSON.stringify(mergedInput)}`);
+    const dataAccessor = server.getDataAccessor(options);
+    const id = mergedInput.id;
+    const row = await dataAccessor.findById(id);
+    if (!row) {
+        throw new Error(`${options.namespace}.${options.singularCode}  with id "${id}" was not found.`);
+    }
+    const entity = mapDbRowToEntity(dataAccessor.getModel(), row);
+    const changes = getEntityPartChanges(entity, mergedInput);
+    if (!changes) {
+        ctx.output = entity;
+        return;
+    }
+    const output = await updateEntityById(server, dataAccessor, { id, entity, changes });
+    ctx.output = output;
+    server.emitEvent("entity.update", plugin, {
+        namespace: options.namespace,
+        modelSingularCode: options.singularCode,
+        before: entity,
+        after: output,
+        changes: changes,
+    });
+}
+
+var updateCollectionEntityById = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  code: code$d,
+  handler: handler$9
+});
+
+const code$c = "deleteCollectionEntityById";
+async function handler$8(plugin, ctx, options) {
+    console.debug(`Running ${code$c} handler...`);
+    const { server, input } = ctx;
+    const dataAccessor = server.getDataAccessor(options);
+    const id = input.id;
+    const row = await dataAccessor.findById(id);
+    if (!row) {
+        ctx.routerContext.status = 200;
+        return;
+    }
+    await dataAccessor.deleteById(id);
+    const entity = mapDbRowToEntity(dataAccessor.getModel(), row);
+    server.emitEvent("entity.delete", plugin, {
+        namespace: options.namespace,
+        modelSingularCode: options.singularCode,
+        before: entity,
+    });
+    ctx.routerContext.status = 200;
+}
+
+var deleteCollectionEntityById = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  code: code$c,
+  handler: handler$8
+});
+
+const code$b = "addEntityRelations";
+async function handler$7(plugin, ctx, options) {
+    const { server, input } = ctx;
+    const { queryBuilder } = server;
+    const { defaultInput, fixedInput } = options;
+    console.debug(`Running ${code$b} handler...`);
+    console.debug(`defaultInput: ${JSON.stringify(defaultInput)}`);
+    const mergedInput = mergeInput(defaultInput, input, fixedInput);
+    console.debug(`fixedInput: ${JSON.stringify(fixedInput)}`);
+    console.debug(`mergedInput: ${JSON.stringify(mergedInput)}`);
+    const dataAccessor = server.getDataAccessor(options);
+    const model = dataAccessor.getModel();
+    const { id, property, relations } = mergedInput;
+    const row = await dataAccessor.findById(id);
+    if (!row) {
+        throw new Error(`${options.namespace}.${options.singularCode}  with id "${id}" was not found.`);
+    }
+    console.log(mergedInput);
+    const relationProperty = model.properties.find(e => e.code === property);
+    if (!relationProperty) {
+        throw new Error(`Property '${property}' was not found in ${options.namespace}.${options.singularCode}`);
+    }
+    if (!(isRelationProperty(relationProperty) && relationProperty.relation === "many")) {
+        throw new Error(`Operation 'createEntityRelations' is only supported on property of 'many' relation`);
+    }
+    if (relationProperty.linkTableName) {
+        for (const relation of relations) {
+            const command = `INSERT INTO ${queryBuilder.quoteTable({ schema: relationProperty.linkSchema, tableName: relationProperty.linkTableName })} (${queryBuilder.quoteObject(relationProperty.selfIdColumnName)}, ${queryBuilder.quoteObject(relationProperty.targetIdColumnName)})
+  SELECT $1, $2 WHERE NOT EXISTS (
+    SELECT ${queryBuilder.quoteObject(relationProperty.selfIdColumnName)}, ${queryBuilder.quoteObject(relationProperty.targetIdColumnName)}
+      FROM ${queryBuilder.quoteTable({ schema: relationProperty.linkSchema, tableName: relationProperty.linkTableName })}
+      WHERE ${queryBuilder.quoteObject(relationProperty.selfIdColumnName)}=$1 AND ${queryBuilder.quoteObject(relationProperty.targetIdColumnName)}=$2
+    )`;
+            const params = [id, relation.id];
+            await server.queryDatabaseObject(command, params);
+        }
+    }
+    ctx.output = {};
+    server.emitEvent("entity.addRelations", plugin, {
+        namespace: options.namespace,
+        modelSingularCode: options.singularCode,
+        entity: row,
+        property,
+        relations: relations,
+    });
+}
+
+var addEntityRelations = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  code: code$b,
+  handler: handler$7
+});
+
+const code$a = "removeEntityRelations";
+async function handler$6(plugin, ctx, options) {
+    const { server, input } = ctx;
+    const { queryBuilder } = server;
+    const { defaultInput, fixedInput } = options;
+    console.debug(`Running ${code$a} handler...`);
+    console.debug(`defaultInput: ${JSON.stringify(defaultInput)}`);
+    const mergedInput = mergeInput(defaultInput, input, fixedInput);
+    console.debug(`fixedInput: ${JSON.stringify(fixedInput)}`);
+    console.debug(`mergedInput: ${JSON.stringify(mergedInput)}`);
+    const dataAccessor = server.getDataAccessor(options);
+    const model = dataAccessor.getModel();
+    const { id, property, relations } = mergedInput;
+    const row = await dataAccessor.findById(id);
+    if (!row) {
+        throw new Error(`${options.namespace}.${options.singularCode}  with id "${id}" was not found.`);
+    }
+    console.log(mergedInput);
+    const relationProperty = model.properties.find(e => e.code === property);
+    if (!relationProperty) {
+        throw new Error(`Property '${property}' was not found in ${options.namespace}.${options.singularCode}`);
+    }
+    if (!(isRelationProperty(relationProperty) && relationProperty.relation === "many")) {
+        throw new Error(`Operation 'createEntityRelations' is only supported on property of 'many' relation`);
+    }
+    if (relationProperty.linkTableName) {
+        for (const relation of relations) {
+            const command = `DELETE FROM ${queryBuilder.quoteTable({ schema: relationProperty.linkSchema, tableName: relationProperty.linkTableName })}
+  WHERE ${queryBuilder.quoteObject(relationProperty.selfIdColumnName)}=$1 AND ${queryBuilder.quoteObject(relationProperty.targetIdColumnName)}=$2;`;
+            const params = [id, relation.id];
+            await server.queryDatabaseObject(command, params);
+        }
+    }
+    ctx.output = {};
+    server.emitEvent("entity.removeRelations", plugin, {
+        namespace: options.namespace,
+        modelSingularCode: options.singularCode,
+        entity: row,
+        property,
+        relations: relations,
+    });
+}
+
+var removeEntityRelations = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  code: code$a,
+  handler: handler$6
+});
+
+const code$9 = "queryDatabase";
+async function handler$5(plugin, ctx, options) {
+    const { server, input } = ctx;
+    const { sql, querySingle, defaultInput, fixedInput } = options;
+    console.debug(`Running ${code$9} handler...`);
+    console.debug(`defaultInput: ${JSON.stringify(defaultInput)}`);
+    const mergedInput = mergeInput(defaultInput, input, fixedInput);
+    console.debug(`fixedInput: ${JSON.stringify(fixedInput)}`);
+    console.debug(`mergedInput: ${JSON.stringify(mergedInput)}`);
+    const result = await server.queryDatabaseObject(sql, mergedInput);
+    if (querySingle) {
+        ctx.output = ___namespace.first(result);
+    }
+    else {
+        ctx.output = result;
+    }
+}
+
+var queryDatabase = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  code: code$9,
+  handler: handler$5
+});
+
+/**
+ * Support manage data in database.
+ * This plugin provide:
+ * - routes for manage data in database.
+ */
+const code$8 = "dataManager";
+const description$3 = "对数据进行管理，提供增删改查等接口。";
+const extendingAbilities$3 = [];
+const configurableTargets$3 = [];
+const configurations$3 = [];
+const routeConfigs = [
+    {
+        code: "createBatch",
+        method: "post",
+        endpoint: "/operations/create_batch",
+        handlerCode: "createCollectionEntitiesBatch",
+    },
+    {
+        code: "find",
+        method: "post",
+        endpoint: "/operations/find",
+        handlerCode: "findCollectionEntities",
+    },
+    {
+        code: "count",
+        method: "post",
+        endpoint: "/operations/count",
+        handlerCode: "countCollectionEntities",
+    },
+    {
+        code: "addRelations",
+        method: "post",
+        endpoint: "/operations/add_relations",
+        handlerCode: "addEntityRelations",
+    },
+    {
+        code: "removeRelations",
+        method: "post",
+        endpoint: "/operations/remove_relations",
+        handlerCode: "removeEntityRelations",
+    },
+    {
+        code: "getById",
+        method: "get",
+        endpoint: "/:id",
+        handlerCode: "findCollectionEntityById",
+    },
+    {
+        code: "create",
+        method: "post",
+        endpoint: "",
+        handlerCode: "createCollectionEntity",
+    },
+    {
+        code: "updateById",
+        method: "post",
+        endpoint: "/:id",
+        handlerCode: "updateCollectionEntityById",
+    },
+    {
+        code: "deleteById",
+        method: "delete",
+        endpoint: "/:id",
+        handlerCode: "deleteCollectionEntityById",
+    },
+];
+let _plugin$3;
+async function initPlugin$3(plugin, server) {
+    _plugin$3 = plugin;
+}
+async function registerHttpHandlers$3(server) {
+    server.registerHttpHandler(_plugin$3, findCollectionEntitiesHttpHandler);
+    server.registerHttpHandler(_plugin$3, findCollectionEntityById);
+    server.registerHttpHandler(_plugin$3, countCollectionEntities);
+    server.registerHttpHandler(_plugin$3, createCollectionEntity);
+    server.registerHttpHandler(_plugin$3, createCollectionEntitiesBatch);
+    server.registerHttpHandler(_plugin$3, updateCollectionEntityById);
+    server.registerHttpHandler(_plugin$3, addEntityRelations);
+    server.registerHttpHandler(_plugin$3, removeEntityRelations);
+    server.registerHttpHandler(_plugin$3, deleteCollectionEntityById);
+    server.registerHttpHandler(_plugin$3, queryDatabase);
+}
+async function configureRoutes$3(server, applicationConfig) {
+    const { routes, models } = applicationConfig;
+    models.forEach((model) => {
+        const { namespace, singularCode, pluralCode } = model;
+        routeConfigs.forEach((routeConfig) => {
+            routes.push({
+                namespace,
+                name: `${namespace}.${singularCode}.${routeConfig.code}`,
+                code: `${namespace}.${singularCode}.${routeConfig.code}`,
+                type: "RESTful",
+                method: routeConfig.method,
+                endpoint: `/api/${namespace}/${pluralCode}${routeConfig.endpoint}`,
+                handlers: [
+                    {
+                        code: routeConfig.handlerCode,
+                        config: {
+                            namespace,
+                            singularCode,
+                        },
+                    },
+                ],
+            });
+        });
+    });
+}
+async function onApplicationLoaded$4(server, application) {
+    console.log("[dataManager.onApplicationLoaded]");
+}
+
+var dataManager = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  code: code$8,
+  description: description$3,
+  extendingAbilities: extendingAbilities$3,
+  configurableTargets: configurableTargets$3,
+  configurations: configurations$3,
+  initPlugin: initPlugin$3,
+  registerHttpHandlers: registerHttpHandlers$3,
+  configureRoutes: configureRoutes$3,
+  onApplicationLoaded: onApplicationLoaded$4
+});
+
+async function fetchWithTimeout(url, reqInit, timeout) {
+    if (!timeout) {
+        return await fetch(url, reqInit);
+    }
+    let timer;
+    const [res] = await Promise.all([
+        fetch(url, reqInit).then((res) => {
+            clearTimeout(timer);
+            return res;
+        }),
+        new Promise((_, reject) => {
+            timer = setTimeout(() => {
+                reject(new Error(`Request to "${url}" was timeout.`));
+            }, timeout);
+        }),
+    ]);
+    return res;
+}
+
+async function doProxy(sourceRouterCtx, options) {
+    const proxyCtx = createProxyContext(sourceRouterCtx, options);
+    const targetRes = await sendTargetRequest(proxyCtx);
+    sendSourceResponse(proxyCtx, targetRes);
+}
+function createProxyContext(sourceRouterCtx, options) {
+    return {
+        sourceContext: {
+            request: sourceRouterCtx.request,
+            response: sourceRouterCtx.response,
+        },
+        targetContext: {},
+        options: options,
+    };
+}
+async function sendTargetRequest(proxyCtx) {
+    const { sourceContext, options: proxyOptions } = proxyCtx;
+    const { target, timeout } = proxyOptions;
+    const { request: srcReq } = sourceContext;
+    const { method } = srcReq;
+    const reqInit = {
+        method,
+    };
+    return await fetchWithTimeout(target, reqInit, timeout);
+}
+async function sendSourceResponse(proxyCtx, targetRes) {
+    const { response: srcRes } = proxyCtx.sourceContext;
+    srcRes.status = targetRes.status;
+    srcRes.body = targetRes.body;
+}
+
+const code$7 = "httpProxy";
+async function handler$4(plugin, ctx, options) {
+    console.debug(`Running ${code$7} handler...`);
+    await doProxy(ctx.routerContext, options);
+}
+
+var httpProxy = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  code: code$7,
+  handler: handler$4
+});
+
+const code$6 = "listMetaRoutes";
+async function handler$3(plugin, ctx, options) {
+    const { applicationConfig } = ctx;
+    ctx.output = { list: applicationConfig.routes };
+}
+
+var listMetaRoutes = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  code: code$6,
+  handler: handler$3
+});
+
+async function buildRoutes(server, applicationConfig) {
+    const router = new Router__default["default"]();
+    applicationConfig.routes.forEach((routeConfig) => {
+        if (routeConfig.type !== "RESTful") {
+            return;
+        }
+        router[routeConfig.method](routeConfig.endpoint, async (routerContext, next) => {
+            const { request, params } = routerContext;
+            let search = request.url.search;
+            if (search && search.startsWith("?")) {
+                search = search.substring(1);
+            }
+            const query = qs__default["default"].parse(search);
+            const input = Object.assign({}, params, query);
+            const requestMethod = request.method;
+            if ((requestMethod === "POST" || requestMethod === "PUT" ||
+                requestMethod === "PATCH") && request.hasBody) {
+                const body = request.body();
+                if (body.type === "form-data") {
+                    const formDataReader = body.value;
+                    const formDataBody = await formDataReader.read({ maxFileSize: 1073741824 /* 1GB */ });
+                    Object.assign(input, {
+                        formData: formDataBody
+                    });
+                }
+                else {
+                    Object.assign(input, await body.value);
+                }
+            }
+            // Normalize input value
+            console.debug(`${requestMethod} ${request.url.toString()}`);
+            console.debug(`input: ${JSON.stringify(input)}`);
+            let handlerContext = {
+                routerContext,
+                next,
+                server,
+                applicationConfig,
+                input,
+            };
+            for (const handlerConfig of routeConfig.handlers) {
+                const handler = server.getHttpHandlerByCode(handlerConfig.code);
+                if (!handler) {
+                    throw new Error("Unknown handler: " + handlerConfig.code);
+                }
+                const result = handler(handlerContext, handlerConfig.config);
+                if (result instanceof Promise) {
+                    await result;
+                }
+            }
+            if (handlerContext.status) {
+                routerContext.status = handlerContext.status;
+            }
+            if (!isNullOrUndefined(handlerContext.output)) {
+                routerContext.json(handlerContext.output);
+            }
+        });
+    });
+    return router.routes();
+}
+
+/**
+ * Route manager plugin
+ */
+const code$5 = "routeManager";
+const description$2 = "routeManager";
+const extendingAbilities$2 = [];
+const configurableTargets$2 = [];
+const configurations$2 = [];
+let _plugin$2;
+async function initPlugin$2(plugin, server) {
+    _plugin$2 = plugin;
+}
+async function registerMiddlewares$1(server) {
+    // server.registerMiddleware(routeHandler);
+}
+// export async function registerEventHandlers(server: IRpdServer) {
+//   server.registerEventHandler("entity.create", handleEntityEvent.bind(null, server))
+//   server.registerEventHandler("entity.update", handleEntityEvent.bind(null, server))
+//   server.registerEventHandler("entity.delete", handleEntityEvent.bind(null, server))
+// }
+// async function handleEntityEvent(server: IRpdServer, sender: IPluginInstance, payload: RpdEntityCreateEventPayload | RpdEntityUpdateEventPayload | RpdEntityDeleteEventPayload) {
+//   if (sender === _plugin) {
+//     return;
+//   }
+//   if (payload.namespace === "meta" && payload.modelSingularCode === "route") {
+//     console.debug("Rebuilding routes...");
+//     routesRef.value = await buildRoutes(server, server.getApplicationConfig());
+//   }
+// }
+async function registerHttpHandlers$2(server) {
+    server.registerHttpHandler(_plugin$2, httpProxy);
+    server.registerHttpHandler(_plugin$2, listMetaRoutes);
+}
+async function configureRoutes$2(server, applicationConfig) {
+    try {
+        const routes = await listRoutes(server, applicationConfig);
+        applicationConfig.routes.push(...routes);
+    }
+    catch (ex) {
+        console.warn("Failed to loading existing meta of routes.", ex.message);
+    }
+}
+function listRoutes(server, applicationConfig) {
+    const dataAccessor = server.getDataAccessor({
+        namespace: "meta",
+        singularCode: "route",
+    });
+    return findEntities(server, dataAccessor, {
+        orderBy: [
+            { field: "endpoint" },
+        ],
+    });
+}
+async function onApplicationLoaded$3(server, applicationConfig) {
+    console.log("[routeManager.onApplicationLoaded] build routes");
+    await buildRoutes(server, applicationConfig);
+}
+
+var routeManager = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  code: code$5,
+  description: description$2,
+  extendingAbilities: extendingAbilities$2,
+  configurableTargets: configurableTargets$2,
+  configurations: configurations$2,
+  initPlugin: initPlugin$2,
+  registerMiddlewares: registerMiddlewares$1,
+  registerHttpHandlers: registerHttpHandlers$2,
+  configureRoutes: configureRoutes$2,
+  onApplicationLoaded: onApplicationLoaded$3
+});
+
+var pluginConfig = {
+    models: [
+        {
+            name: "webhook",
+            namespace: "sys",
+            singularCode: "webhook",
+            pluralCode: "webhooks",
+            schema: "public",
+            tableName: "sys_webhooks",
+            properties: [
+                {
+                    name: "id",
+                    code: "id",
+                    columnName: "id",
+                    type: "integer",
+                    required: true,
+                    autoIncrement: true,
+                },
+                {
+                    name: "name",
+                    code: "name",
+                    columnName: "name",
+                    type: "text",
+                    required: true,
+                },
+                {
+                    name: "url",
+                    code: "url",
+                    columnName: "url",
+                    type: "text",
+                    required: true,
+                },
+                {
+                    name: "secret",
+                    code: "secret",
+                    columnName: "secret",
+                    type: "text",
+                    required: false,
+                },
+                {
+                    name: "namespace",
+                    code: "namespace",
+                    columnName: "namespace",
+                    type: "text",
+                    required: true,
+                },
+                {
+                    name: "model singular code",
+                    code: "modelSingularCode",
+                    columnName: "model_singular_code",
+                    type: "text",
+                    required: true,
+                },
+                {
+                    name: "events",
+                    code: "events",
+                    columnName: "events",
+                    type: "json",
+                    required: false,
+                },
+                {
+                    name: "enabled",
+                    code: "enabled",
+                    columnName: "enabled",
+                    type: "boolean",
+                    required: true,
+                },
+            ],
+        },
+    ],
+    routes: [],
+};
+
+/**
+ * Webhooks plugin
+ */
+const code$4 = "webhooks";
+const description$1 = "webhooks";
+const extendingAbilities$1 = [];
+const configurableTargets$1 = [];
+const configurations$1 = [];
+let _plugin$1;
+let webhooks;
+async function initPlugin$1(plugin, server) {
+    _plugin$1 = plugin;
+}
+async function configureModels$2(server, applicationConfig) {
+    for (const model of pluginConfig.models) {
+        applicationConfig.models.push(model);
+    }
+}
+async function registerEventHandlers$2(server) {
+    const events = [
+        "entity.create",
+        "entity.update",
+        "entity.delete",
+    ];
+    for (const event of events) {
+        server.registerEventHandler(event, handleEntityEvent.bind(null, server, event));
+    }
+}
+async function handleEntityEvent(server, event, sender, payload) {
+    if (sender === _plugin$1) {
+        return;
+    }
+    if (payload.namespace === "sys" && payload.modelSingularCode === "webhook") {
+        webhooks = await listWebhooks(server);
+        return;
+    }
+    // We will not trigger webhooks if entity changed is in "meta" or "sys" namespaces.
+    if (payload.namespace === "meta" || payload.namespace === "sys") {
+        return;
+    }
+    for (const webhook of webhooks) {
+        if (___namespace.indexOf(webhook.events, event) === -1) {
+            continue;
+        }
+        if (webhook.namespace != payload.namespace ||
+            webhook.modelSingularCode !== payload.modelSingularCode) {
+            continue;
+        }
+        console.debug(`Triggering webhook. ${webhook.url}`);
+        // TODO: It's better to trigger webhook through message queue.
+        try {
+            await fetchWithTimeout(webhook.url, {
+                method: "post",
+                headers: {
+                    "Content-Type": "application/json",
+                    "x-webhook-secret": webhook.secret || "",
+                },
+                body: JSON.stringify({ event, payload }),
+            });
+        }
+        catch (err) {
+            console.warn(new Error("Failed to call webhook. " + err.message));
+            console.warn(err);
+        }
+    }
+}
+async function onApplicationLoaded$2(server, applicationConfig) {
+    console.log("[webhooks.onApplicationLoaded] loading webhooks");
+    webhooks = await listWebhooks(server);
+}
+function listWebhooks(server) {
+    const dataAccessor = server.getDataAccessor({
+        namespace: "sys",
+        singularCode: "webhook",
+    });
+    return findEntities(server, dataAccessor, {
+        filters: [
+            {
+                field: "enabled",
+                operator: "eq",
+                value: true,
+            },
+        ],
+    });
+}
+
+var webhooks$1 = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  code: code$4,
+  description: description$1,
+  extendingAbilities: extendingAbilities$1,
+  configurableTargets: configurableTargets$1,
+  configurations: configurations$1,
+  initPlugin: initPlugin$1,
+  configureModels: configureModels$2,
+  registerEventHandlers: registerEventHandlers$2,
+  onApplicationLoaded: onApplicationLoaded$2
+});
+
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+class AssertionError extends Error {
+    name = "AssertionError";
+    constructor(message) {
+        super(message);
+    }
+}
+
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+/** Make an assertion, error will be thrown if `expr` does not have truthy value. */
+function assert(expr, msg = "") {
+    if (!expr) {
+        throw new AssertionError(msg);
+    }
+}
+
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+/**
+ * Formats the given date to IMF date time format. (Reference:
+ * https://tools.ietf.org/html/rfc7231#section-7.1.1.1).
+ * IMF is the time format to use when generating times in HTTP
+ * headers. The time being formatted must be in UTC for Format to
+ * generate the correct format.
+ *
+ * @example
+ * ```ts
+ * import { toIMF } from "https://deno.land/std@$STD_VERSION/datetime/to_imf.ts";
+ *
+ * toIMF(new Date(0)); // => returns "Thu, 01 Jan 1970 00:00:00 GMT"
+ * ```
+ * @param date Date to parse
+ * @return IMF date formatted string
+ */
+function toIMF(date) {
+    function dtPad(v, lPad = 2) {
+        return v.padStart(lPad, "0");
+    }
+    const d = dtPad(date.getUTCDate().toString());
+    const h = dtPad(date.getUTCHours().toString());
+    const min = dtPad(date.getUTCMinutes().toString());
+    const s = dtPad(date.getUTCSeconds().toString());
+    const y = date.getUTCFullYear();
+    const days = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"];
+    const months = [
+        "Jan",
+        "Feb",
+        "Mar",
+        "Apr",
+        "May",
+        "Jun",
+        "Jul",
+        "Aug",
+        "Sep",
+        "Oct",
+        "Nov",
+        "Dec",
+    ];
+    return `${days[date.getUTCDay()]}, ${d} ${months[date.getUTCMonth()]} ${y} ${h}:${min}:${s} GMT`;
+}
+
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+const FIELD_CONTENT_REGEXP = /^(?=[\x20-\x7E]*$)[^()@<>,;:\\"\[\]?={}\s]+$/;
+function toString(cookie) {
+    if (!cookie.name) {
+        return "";
+    }
+    const out = [];
+    validateName(cookie.name);
+    validateValue(cookie.name, cookie.value);
+    out.push(`${cookie.name}=${cookie.value}`);
+    // Fallback for invalid Set-Cookie
+    // ref: https://tools.ietf.org/html/draft-ietf-httpbis-cookie-prefixes-00#section-3.1
+    if (cookie.name.startsWith("__Secure")) {
+        cookie.secure = true;
+    }
+    if (cookie.name.startsWith("__Host")) {
+        cookie.path = "/";
+        cookie.secure = true;
+        delete cookie.domain;
+    }
+    if (cookie.secure) {
+        out.push("Secure");
+    }
+    if (cookie.httpOnly) {
+        out.push("HttpOnly");
+    }
+    if (typeof cookie.maxAge === "number" && Number.isInteger(cookie.maxAge)) {
+        assert(cookie.maxAge >= 0, "Max-Age must be an integer superior or equal to 0");
+        out.push(`Max-Age=${cookie.maxAge}`);
+    }
+    if (cookie.domain) {
+        validateDomain(cookie.domain);
+        out.push(`Domain=${cookie.domain}`);
+    }
+    if (cookie.sameSite) {
+        out.push(`SameSite=${cookie.sameSite}`);
+    }
+    if (cookie.path) {
+        validatePath(cookie.path);
+        out.push(`Path=${cookie.path}`);
+    }
+    if (cookie.expires) {
+        const { expires } = cookie;
+        const dateString = toIMF(typeof expires === "number" ? new Date(expires) : expires);
+        out.push(`Expires=${dateString}`);
+    }
+    if (cookie.unparsed) {
+        out.push(cookie.unparsed.join("; "));
+    }
+    return out.join("; ");
+}
+/**
+ * Validate Cookie Name.
+ * @param name Cookie name.
+ */
+function validateName(name) {
+    if (name && !FIELD_CONTENT_REGEXP.test(name)) {
+        throw new TypeError(`Invalid cookie name: "${name}".`);
+    }
+}
+/**
+ * Validate Path Value.
+ * See {@link https://tools.ietf.org/html/rfc6265#section-4.1.2.4}.
+ * @param path Path value.
+ */
+function validatePath(path) {
+    if (path == null) {
+        return;
+    }
+    for (let i = 0; i < path.length; i++) {
+        const c = path.charAt(i);
+        if (c < String.fromCharCode(0x20) || c > String.fromCharCode(0x7E) || c == ";") {
+            throw new Error(path + ": Invalid cookie path char '" + c + "'");
+        }
+    }
+}
+/**
+ * Validate Cookie Value.
+ * See {@link https://tools.ietf.org/html/rfc6265#section-4.1}.
+ * @param value Cookie value.
+ */
+function validateValue(name, value) {
+    if (value == null || name == null)
+        return;
+    for (let i = 0; i < value.length; i++) {
+        const c = value.charAt(i);
+        if (c < String.fromCharCode(0x21) || c == String.fromCharCode(0x22) ||
+            c == String.fromCharCode(0x2c) || c == String.fromCharCode(0x3b) ||
+            c == String.fromCharCode(0x5c) || c == String.fromCharCode(0x7f)) {
+            throw new Error("RFC2616 cookie '" + name + "' cannot contain character '" + c + "'");
+        }
+        if (c > String.fromCharCode(0x80)) {
+            throw new Error("RFC2616 cookie '" + name + "' can only have US-ASCII chars as value" +
+                c.charCodeAt(0).toString(16));
+        }
+    }
+}
+/**
+ * Validate Cookie Domain.
+ * See {@link https://datatracker.ietf.org/doc/html/rfc6265#section-4.1.2.3}.
+ * @param domain Cookie domain.
+ */
+function validateDomain(domain) {
+    if (domain == null) {
+        return;
+    }
+    const char1 = domain.charAt(0);
+    const charN = domain.charAt(domain.length - 1);
+    if (char1 == "-" || charN == "." || charN == "-") {
+        throw new Error("Invalid first/last char in cookie domain: " + domain);
+    }
+}
+/**
+ * Set the cookie header properly in the headers
+ *
+ * @example
+ * ```ts
+ * import {
+ *   Cookie,
+ *   setCookie,
+ * } from "https://deno.land/std@$STD_VERSION/http/cookie.ts";
+ *
+ * const headers = new Headers();
+ * const cookie: Cookie = { name: "Space", value: "Cat" };
+ * setCookie(headers, cookie);
+ *
+ * const cookieHeader = headers.get("set-cookie");
+ * console.log(cookieHeader); // Space=Cat
+ * ```
+ *
+ * @param headers The headers instance to set the cookie to
+ * @param cookie Cookie to set
+ */
+function setCookie(headers, cookie) {
+    // Parsing cookie headers to make consistent set-cookie header
+    // ref: https://tools.ietf.org/html/rfc6265#section-4.1.1
+    const v = toString(cookie);
+    if (v) {
+        headers.append("Set-Cookie", v);
+    }
+}
+
+async function createJWT(payload) {
+    return "";
+}
+
+const code$3 = "createSession";
+async function handler$2(plugin, ctx, options) {
+    const { server, input, routerContext } = ctx;
+    const { response } = routerContext;
+    const { account, password } = input;
+    const userDataAccessor = server.getDataAccessor({
+        singularCode: "oc_user",
+    });
+    const user = await userDataAccessor.findOne({
+        filters: [
+            {
+                operator: "eq",
+                field: "login",
+                value: account,
+            }
+        ]
+    });
+    if (!user) {
+        throw new Error("Wrong account or password.");
+    }
+    const token = await createJWT({
+        iss: "authManager",
+        sub: "userAccessToken",
+        aud: "" + user.id,
+        iat: new Date,
+        act: user.login,
+    });
+    setCookie(response.headers, {
+        name: ctx.server.config.sessionCookieName,
+        value: token,
+        path: "/",
+    });
+    ctx.output = {
+        token,
+    };
+}
+
+var createSession = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  code: code$3,
+  handler: handler$2
+});
+
+const code$2 = "deleteSession";
+async function handler$1(plugin, ctx, options) {
+    const { server, input, routerContext } = ctx;
+    const { response } = routerContext;
+    setCookie(response.headers, {
+        name: ctx.server.config.sessionCookieName,
+        value: "",
+        path: "/",
+    });
+    routerContext.redirect("/signin");
+}
+
+var deleteSession = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  code: code$2,
+  handler: handler$1
+});
+
+const code$1 = "getMyProfile";
+async function handler(plugin, ctx, options) {
+    const { server, input, routerContext } = ctx;
+    const userId = routerContext.state.userId;
+    if (!userId) {
+        ctx.status = 401;
+        ctx.output = {
+            error: {
+                message: "You are not signed in."
+            }
+        };
+        return;
+    }
+    const userDataAccessor = server.getDataAccessor({
+        singularCode: "oc_user",
+    });
+    const user = await findEntity(server, userDataAccessor, {
+        filters: [
+            {
+                operator: "eq",
+                field: "id",
+                value: userId,
+            }
+        ],
+        properties: ["id", "name", "login", "email", "department", "roles", "state", "createdAt"],
+    });
+    ctx.output = {
+        user,
+    };
+}
+
+var getMyProfile$1 = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  code: code$1,
+  handler: handler
+});
+
+var pluginHttpHandlers = [
+    createSession,
+    deleteSession,
+    getMyProfile$1,
+];
+
+var AccessToken = {
+    maintainedBy: "authManager",
+    namespace: "auth",
+    name: "access_token",
+    singularCode: "access_token",
+    pluralCode: "access_tokens",
+    schema: "public",
+    tableName: "access_tokens",
+    properties: [
+        {
+            name: "id",
+            code: "id",
+            columnName: "id",
+            type: "integer",
+            required: true,
+            autoIncrement: true,
+        },
+        {
+            name: "token",
+            code: "token",
+            columnName: "token",
+            type: "text",
+            required: true,
+        },
+        {
+            name: "description",
+            code: "description",
+            columnName: "description",
+            type: "text",
+            required: false,
+        },
+        {
+            name: "ownerType",
+            code: "ownerType",
+            columnName: "owner_type",
+            type: "text",
+            required: true,
+        },
+        {
+            name: "ownerId",
+            code: "ownerId",
+            columnName: "owner_id",
+            type: "integer",
+            required: true,
+        },
+        {
+            name: "expirationTime",
+            code: "expirationTime",
+            columnName: "expiration_time",
+            type: "datetime",
+            required: true,
+        },
+    ],
+};
+
+var pluginModels = [
+    AccessToken,
+];
+
+var getMyProfile = {
+    namespace: "auth",
+    name: "auth.getMyProfile",
+    code: "",
+    type: "RESTful",
+    method: "get",
+    endpoint: "/api/me",
+    handlers: [
+        {
+            code: "getMyProfile",
+        },
+    ],
+};
+
+var signin = {
+    namespace: "auth",
+    name: "auth.signin",
+    code: "",
+    type: "RESTful",
+    method: "post",
+    endpoint: "/api/signin",
+    handlers: [
+        {
+            code: "createSession",
+        },
+    ],
+};
+
+var signout = {
+    namespace: "auth",
+    name: "auth.signout",
+    code: "",
+    type: "RESTful",
+    method: "get",
+    endpoint: "/api/signout",
+    handlers: [
+        {
+            code: "deleteSession",
+        },
+    ],
+};
+
+var pluginRoutes = [
+    getMyProfile,
+    signin,
+    signout,
+];
+
+/**
+ * Meta manager plugin
+ */
+const code = "authManager";
+const description = "authManager";
+const extendingAbilities = [];
+const configurableTargets = [];
+const configurations = [];
+let _plugin;
+async function initPlugin(plugin, server) {
+    _plugin = plugin;
+}
+async function registerHttpHandlers$1(server) {
+    for (const httpHandler of pluginHttpHandlers) {
+        server.registerHttpHandler(_plugin, httpHandler);
+    }
+}
+async function registerEventHandlers$1(server) {
+}
+async function configureModels$1(server, applicationConfig) {
+    applicationConfig.models.push(...pluginModels);
+}
+async function configureRoutes$1(server, applicationConfig) {
+    applicationConfig.routes.push(...pluginRoutes);
+}
+async function onApplicationLoaded$1(server, applicationConfig) {
+    console.log("authManager.onApplicationLoaded");
+}
+
+var authManager = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  code: code,
+  description: description,
+  extendingAbilities: extendingAbilities,
+  configurableTargets: configurableTargets,
+  configurations: configurations,
+  initPlugin: initPlugin,
+  registerHttpHandlers: registerHttpHandlers$1,
+  registerEventHandlers: registerEventHandlers$1,
+  configureModels: configureModels$1,
+  configureRoutes: configureRoutes$1,
+  onApplicationLoaded: onApplicationLoaded$1
+});
+
+const plugins = [];
+async function loadPlugins() {
+    plugins.push(metaManager);
+    plugins.push(dataManager);
+    plugins.push(routeManager);
+    plugins.push(webhooks$1);
+    plugins.push(authManager);
+}
+/** 初始化插件时调用。 */
+async function initPlugins(server) {
+    for (const plugin of plugins) {
+        const pluginInstance = new Plugin(plugin.code);
+        await plugin.initPlugin(pluginInstance, server);
+    }
+}
+/** 注册中间件 */
+async function registerMiddlewares(server) {
+    for (const plugin of plugins) {
+        if (plugin.registerMiddlewares) {
+            await plugin.registerMiddlewares(server);
+        }
+    }
+}
+/** 注册接口动作处理程序 */
+async function registerHttpHandlers(server) {
+    for (const plugin of plugins) {
+        if (plugin.registerHttpHandlers) {
+            await plugin.registerHttpHandlers(server);
+        }
+    }
+}
+/** 注册事件处理程序 */
+async function registerEventHandlers(server) {
+    for (const plugin of plugins) {
+        if (plugin.registerEventHandlers) {
+            await plugin.registerEventHandlers(server);
+        }
+    }
+}
+/** 注册消息处理程序 */
+async function registerMessageHandlers(server) {
+    for (const plugin of plugins) {
+        if (plugin.registerMessageHandlers) {
+            await plugin.registerMessageHandlers(server);
+        }
+    }
+}
+/** 注册任务处理程序 */
+async function registerTaskProcessors(server) {
+    for (const plugin of plugins) {
+        if (plugin.registerTaskProcessors) {
+            await plugin.registerTaskProcessors(server);
+        }
+    }
+}
+/** 在加载应用前调用。 */
+async function onLoadingApplication(server, applicationConfig) {
+    for (const plugin of plugins) {
+        if (plugin.onLoadingApplication) {
+            await plugin.onLoadingApplication(server, applicationConfig);
+        }
+    }
+}
+/** 配置数据模型 */
+async function configureModels(server, applicationConfig) {
+    for (const plugin of plugins) {
+        if (plugin.configureModels) {
+            await plugin.configureModels(server, applicationConfig);
+        }
+    }
+}
+/** 配置模型属性 */
+async function configureModelProperties(server, applicationConfig) {
+    for (const plugin of plugins) {
+        if (plugin.configureModelProperties) {
+            await plugin.configureModelProperties(server, applicationConfig);
+        }
+    }
+}
+/** 配置路由 */
+async function configureRoutes(server, applicationConfig) {
+    for (const plugin of plugins) {
+        if (plugin.configureRoutes) {
+            await plugin.configureRoutes(server, applicationConfig);
+        }
+    }
+}
+/** 在应用配置加载完成后调用。此时插件可以进行一些数据的初始化工作。 */
+async function onApplicationLoaded(server, applicationConfig) {
+    for (const plugin of plugins) {
+        if (plugin.onApplicationLoaded) {
+            await plugin.onApplicationLoaded(server, applicationConfig);
+        }
+    }
+}
+/** 在应用准备完成后调用。此时服务器已经可以处理网络请求。 */
+async function onApplicationReady(server, applicationConfig) {
+    for (const plugin of plugins) {
+        if (plugin.onApplicationReady) {
+            await plugin.onApplicationReady(server, applicationConfig);
+        }
+    }
+}
+
+class EventManager {
+    #eventEmitter;
+    constructor() {
+        this.#eventEmitter = new events.EventEmitter();
+    }
+    on(eventName, listener) {
+        this.#eventEmitter.on(eventName, listener);
+    }
+    emit(eventName, ...args) {
+        return this.#eventEmitter.emit(eventName, ...args);
+    }
+}
+
+function mergeHeaders(target, source) {
+    if (source instanceof Headers) {
+        for (const keyValuePair of source.entries()) {
+            target.set(keyValuePair[0], keyValuePair[1]);
+        }
+    }
+    else if (_.isArray(source)) {
+        for (const keyValuePair of source) {
+            target.set(keyValuePair[0], keyValuePair[1]);
+        }
+    }
+    else if (_.isObject(source)) {
+        Object.entries(source).forEach(([key, value]) => target.set(key, value));
+    }
+    return target;
+}
+function newResponse(options) {
+    return new Response(options.body, {
+        headers: options.headers,
+        status: options.status || 200,
+    });
+}
+class RapidResponse {
+    #response;
+    status;
+    body;
+    headers;
+    constructor(body, init) {
+        this.body = body;
+        this.headers = new Headers(init.headers);
+        this.status = init.status;
+    }
+    json(obj, status, headers) {
+        const body = JSON.stringify(obj);
+        const responseHeaders = new Headers(this.headers);
+        if (headers) {
+            mergeHeaders(responseHeaders, headers);
+        }
+        this.#response = newResponse({ body, status: status || 200, headers: responseHeaders });
+    }
+    redirect(location, status) {
+        this.headers.set("Location", location);
+        this.#response = newResponse({
+            headers: this.headers,
+            status: status || 302,
+        });
+    }
+    getResponse() {
+        if (!this.#response) {
+            this.#response = new Response(this.body, {
+                status: this.status || (this.body ? 200 : 404),
+                headers: this.headers,
+            });
+        }
+        return this.#response;
+    }
+}
+
+class RouteContext {
+    request;
+    response;
+    state;
+    method;
+    path;
+    status;
+    params;
+    constructor(request) {
+        this.request = request;
+        this.state = {};
+        this.response = new RapidResponse();
+    }
+    set(headerName, headerValue) {
+        this.response.headers.set(headerName, headerValue);
+    }
+    json(obj, status, headers) {
+        this.response.json(obj, status, headers);
+    }
+    redirect(url, status) {
+        this.response.redirect(url, status);
+    }
+}
+
+const GlobalRequest = global.Request;
+class RapidRequest {
+    method;
+    url;
+    hasBody;
+    constructor(init) {
+    }
+    body() {
+        return {
+            type: "",
+            value: {}
+        };
+    }
+}
+
+class RpdServer {
+    #eventManager;
+    #middlewares;
+    #bootstrapApplicationConfig;
+    #applicationConfig;
+    #httpHandlersMapByCode;
+    #databaseAccessor;
+    queryBuilder;
+    config;
+    databaseConfig;
+    #buildedRoutes;
+    constructor(options) {
+        this.#eventManager = new EventManager();
+        this.#middlewares = [];
+        this.#bootstrapApplicationConfig = options.applicationConfig;
+        this.#applicationConfig = {};
+        this.#httpHandlersMapByCode = new Map();
+        this.#databaseAccessor = options.databaseAccessor;
+        this.queryBuilder = new QueryBuilder({
+            dbDefaultSchema: options.databaseConfig.dbDefaultSchema,
+        });
+        this.databaseConfig = options.databaseConfig;
+        this.config = options.serverConfig;
+    }
+    getApplicationConfig() {
+        return this.#applicationConfig;
+    }
+    registerHttpHandler(plugin, options) {
+        const handler = ___namespace.bind(options.handler, null, plugin);
+        this.#httpHandlersMapByCode.set(options.code, handler);
+    }
+    getHttpHandlerByCode(code) {
+        return this.#httpHandlersMapByCode.get(code);
+    }
+    registerMiddleware(middleware) {
+        this.#middlewares.push(middleware);
+    }
+    getDataAccessor(options) {
+        const { namespace, singularCode } = options;
+        // TODO: Should reuse the and DataAccessor instance
+        const model = this.getModel(options);
+        if (!model) {
+            throw new Error(`Data model ${namespace}.${singularCode} not found.`);
+        }
+        const dataAccessor = new DataAccessor({
+            model,
+            queryBuilder: this.queryBuilder,
+        });
+        return dataAccessor;
+    }
+    getModel(options) {
+        if (options.namespace) {
+            return this.#applicationConfig?.models.find((e) => e.namespace === options.namespace && e.singularCode === options.singularCode);
+        }
+        return this.#applicationConfig?.models.find((e) => e.singularCode === options.singularCode);
+    }
+    registerEventHandler(eventName, listener) {
+        this.#eventManager.on(eventName, listener);
+        return this;
+    }
+    async emitEvent(eventName, sender, payload) {
+        console.log(`Emit event "${eventName}"`, payload);
+        await this.#eventManager.emit(eventName, sender, payload);
+        // TODO: should move this logic into metaManager
+        // if (
+        //   (eventName === "entity.create" || eventName === "entity.update" ||
+        //     eventName === "entity.delete") &&
+        //   payload.namespace === "meta"
+        // ) {
+        //   await this.configureApplication();
+        // }
+    }
+    async start() {
+        console.log("Starting rapid server...");
+        await loadPlugins();
+        await initPlugins(this);
+        await registerMiddlewares(this);
+        await registerHttpHandlers(this);
+        await registerEventHandlers(this);
+        await registerMessageHandlers(this);
+        await registerTaskProcessors(this);
+        await this.configureApplication();
+        console.log(`Application ready.`);
+        await onApplicationReady(this, this.#applicationConfig);
+    }
+    async configureApplication() {
+        this.#applicationConfig = ___namespace.merge({}, this.#bootstrapApplicationConfig);
+        await onLoadingApplication(this, this.#applicationConfig);
+        await configureModels(this, this.#applicationConfig);
+        await configureModelProperties(this, this.#applicationConfig);
+        await configureRoutes(this, this.#applicationConfig);
+        // TODO: check application configuration.
+        await onApplicationLoaded(this, this.#applicationConfig);
+        this.#buildedRoutes = await buildRoutes(this, this.#applicationConfig);
+    }
+    async queryDatabaseObject(sql, params) {
+        return await this.#databaseAccessor.queryDatabaseObject(sql, params);
+    }
+    async tryQueryDatabaseObject(sql, params) {
+        try {
+            return await this.queryDatabaseObject(sql, params);
+        }
+        catch (err) {
+            console.error(err.message);
+        }
+        return [];
+    }
+    get middlewares() {
+        return this.#middlewares;
+    }
+    async handleRequest(request, next) {
+        const routeContext = new RouteContext(new RapidRequest(request));
+        await this.#buildedRoutes(routeContext, next);
+        return routeContext.response.getResponse();
+    }
+}
+
+var server = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  'default': RpdServer
+});
+
+var bootstrapApplicationConfig = {
+    code: "default",
+    name: "default",
+    models: [
+        {
+            maintainedBy: "metaManager",
+            namespace: "meta",
+            name: "model",
+            singularCode: "model",
+            pluralCode: "models",
+            schema: "public",
+            tableName: "meta_models",
+            properties: [
+                {
+                    name: "id",
+                    code: "id",
+                    columnName: "id",
+                    type: "integer",
+                    required: true,
+                    autoIncrement: true,
+                },
+                {
+                    name: "name",
+                    code: "name",
+                    columnName: "name",
+                    type: "text",
+                    required: true,
+                },
+                {
+                    name: "description",
+                    code: "description",
+                    columnName: "description",
+                    type: "text",
+                    required: false,
+                },
+                {
+                    name: "singular code",
+                    code: "singularCode",
+                    columnName: "singular_code",
+                    type: "text",
+                    required: true,
+                },
+                {
+                    name: "plural code",
+                    code: "pluralCode",
+                    columnName: "plural_code",
+                    type: "text",
+                    required: true,
+                },
+                {
+                    name: "schema",
+                    code: "schema",
+                    columnName: "schema",
+                    type: "text",
+                    required: false,
+                },
+                {
+                    name: "table name",
+                    code: "tableName",
+                    columnName: "table_name",
+                    type: "text",
+                    required: true,
+                },
+                {
+                    name: "namespace",
+                    code: "namespace",
+                    columnName: "namespace",
+                    type: "text",
+                    required: true,
+                },
+                {
+                    name: "properties",
+                    code: "properties",
+                    type: "relation[]",
+                    relation: "many",
+                    targetSingularCode: "property",
+                    selfIdColumnName: "model_id",
+                },
+            ],
+        },
+        {
+            maintainedBy: "metaManager",
+            namespace: "meta",
+            name: "property",
+            singularCode: "property",
+            pluralCode: "properties",
+            schema: "public",
+            tableName: "meta_properties",
+            properties: [
+                {
+                    name: "id",
+                    code: "id",
+                    columnName: "id",
+                    type: "integer",
+                    required: true,
+                    autoIncrement: true,
+                },
+                {
+                    name: "model",
+                    code: "model",
+                    type: "relation",
+                    required: true,
+                    relation: "one",
+                    targetSingularCode: "model",
+                    targetIdColumnName: "model_id",
+                },
+                {
+                    name: "name",
+                    code: "name",
+                    columnName: "name",
+                    type: "text",
+                    required: true,
+                },
+                {
+                    name: "code",
+                    code: "code",
+                    columnName: "code",
+                    type: "text",
+                    required: true,
+                },
+                {
+                    name: "description",
+                    code: "description",
+                    columnName: "description",
+                    type: "text",
+                    required: false,
+                },
+                {
+                    name: "column name",
+                    code: "columnName",
+                    columnName: "column_name",
+                    type: "text",
+                    required: false,
+                },
+                {
+                    name: "type",
+                    code: "type",
+                    columnName: "type",
+                    type: "text",
+                    required: true,
+                },
+                {
+                    name: "required",
+                    code: "required",
+                    columnName: "required",
+                    type: "boolean",
+                    required: true,
+                    defaultValue: "false",
+                },
+                {
+                    name: "default value",
+                    code: "defaultValue",
+                    columnName: "default_value",
+                    type: "text",
+                    required: false,
+                },
+                {
+                    name: "config",
+                    code: "config",
+                    columnName: "config",
+                    type: "json",
+                    required: false,
+                },
+                {
+                    name: "auto increment",
+                    code: "autoIncrement",
+                    columnName: "auto_increment",
+                    type: "boolean",
+                    required: true,
+                    defaultValue: "false",
+                },
+                {
+                    name: "min length",
+                    code: "minLength",
+                    columnName: "min_length",
+                    type: "integer",
+                    required: false,
+                },
+                {
+                    name: "max length",
+                    code: "maxLength",
+                    columnName: "max_length",
+                    type: "integer",
+                    required: false,
+                },
+                {
+                    name: "relation",
+                    code: "relation",
+                    columnName: "relation",
+                    type: "text",
+                    required: false,
+                },
+                {
+                    name: "target singular code",
+                    code: "targetSingularCode",
+                    columnName: "target_singular_code",
+                    type: "text",
+                    required: false,
+                },
+                {
+                    name: "target id column name",
+                    code: "targetIdColumnName",
+                    columnName: "target_id_column_name",
+                    type: "text",
+                    required: false,
+                },
+                {
+                    name: "self id column name",
+                    code: "selfIdColumnName",
+                    columnName: "self_id_column_name",
+                    type: "text",
+                    required: false,
+                },
+                {
+                    name: "link schema",
+                    code: "linkSchema",
+                    columnName: "link_schema",
+                    type: "text",
+                    required: false,
+                },
+                {
+                    name: "link table name",
+                    code: "linkTableName",
+                    columnName: "link_table_name",
+                    type: "text",
+                    required: false,
+                },
+                {
+                    name: "data dictionary",
+                    code: "dataDictionary",
+                    columnName: "data_dictionary",
+                    type: "text",
+                    required: false,
+                },
+            ],
+        },
+        {
+            maintainedBy: "metaManager",
+            namespace: "meta",
+            name: "data dictionary",
+            singularCode: "data_dictionary",
+            pluralCode: "data_dictionaries",
+            schema: "public",
+            tableName: "meta_data_dictionaries",
+            properties: [
+                {
+                    name: "id",
+                    code: "id",
+                    columnName: "id",
+                    type: "integer",
+                    required: true,
+                    autoIncrement: true,
+                },
+                {
+                    name: "code",
+                    code: "code",
+                    columnName: "code",
+                    type: "text",
+                    required: true,
+                },
+                {
+                    name: "name",
+                    code: "name",
+                    columnName: "name",
+                    type: "text",
+                    required: true,
+                },
+                {
+                    name: "valueType",
+                    code: "valueType",
+                    columnName: "value_type",
+                    type: "text",
+                    required: true,
+                },
+                {
+                    name: "level",
+                    code: "level",
+                    columnName: "level",
+                    type: "text",
+                    required: false,
+                    defaultValue: "'app'"
+                },
+                {
+                    name: "description",
+                    code: "description",
+                    columnName: "description",
+                    type: "text",
+                    required: false,
+                },
+                {
+                    name: "source",
+                    code: "source",
+                    columnName: "source",
+                    type: "text",
+                    required: false,
+                },
+                {
+                    name: "externalId",
+                    code: "externalId",
+                    columnName: "external_id",
+                    type: "text",
+                    required: false,
+                },
+                {
+                    name: "externalData",
+                    code: "externalData",
+                    columnName: "external_data",
+                    type: "json",
+                    required: false,
+                },
+                {
+                    name: "state",
+                    code: "state",
+                    columnName: "state",
+                    type: "text",
+                    required: false,
+                },
+                {
+                    name: "entries",
+                    code: "entries",
+                    type: "relation[]",
+                    relation: "many",
+                    targetSingularCode: "data_dictionary_entry",
+                    selfIdColumnName: "dictionary_id",
+                },
+            ]
+        },
+        {
+            maintainedBy: "metaManager",
+            namespace: "meta",
+            name: "data dictionary entry",
+            singularCode: "data_dictionary_entry",
+            pluralCode: "data_dictionary_entries",
+            schema: "public",
+            tableName: "meta_data_dictionary_entries",
+            properties: [
+                {
+                    name: "id",
+                    code: "id",
+                    columnName: "id",
+                    type: "integer",
+                    required: true,
+                    autoIncrement: true,
+                },
+                {
+                    name: "dictionary",
+                    code: "dictionary",
+                    type: "relation",
+                    relation: "one",
+                    targetSingularCode: "data_dictionary",
+                    targetIdColumnName: "dictionary_id",
+                },
+                {
+                    name: "order number",
+                    code: "orderNum",
+                    columnName: "order_num",
+                    type: "integer",
+                    required: true,
+                    defaultValue: 0,
+                },
+                {
+                    name: "name",
+                    code: "name",
+                    columnName: "name",
+                    type: "text",
+                    required: true,
+                },
+                {
+                    name: "value",
+                    code: "value",
+                    columnName: "value",
+                    type: "text",
+                    required: true,
+                },
+                {
+                    name: "color",
+                    code: "color",
+                    columnName: "color",
+                    type: "text",
+                    required: false,
+                },
+                {
+                    name: "icon",
+                    code: "icon",
+                    columnName: "icon",
+                    type: "text",
+                    required: false,
+                },
+                {
+                    name: "description",
+                    code: "description",
+                    columnName: "description",
+                    type: "text",
+                    required: false,
+                },
+                {
+                    name: "disabled",
+                    code: "disabled",
+                    columnName: "disabled",
+                    type: "boolean",
+                    required: false,
+                },
+            ]
+        },
+        {
+            maintainedBy: "dataManager",
+            namespace: "meta",
+            name: "routes",
+            singularCode: "route",
+            pluralCode: "routes",
+            schema: "public",
+            tableName: "meta_routes",
+            properties: [
+                {
+                    name: "id",
+                    code: "id",
+                    columnName: "id",
+                    type: "integer",
+                    required: true,
+                    autoIncrement: true,
+                },
+                {
+                    name: "namespace",
+                    code: "namespace",
+                    columnName: "namespace",
+                    type: "text",
+                    required: true,
+                },
+                {
+                    name: "code",
+                    code: "code",
+                    columnName: "code",
+                    type: "text",
+                    required: true,
+                },
+                {
+                    name: "name",
+                    code: "name",
+                    columnName: "name",
+                    type: "text",
+                    required: true,
+                },
+                {
+                    name: "description",
+                    code: "description",
+                    columnName: "description",
+                    type: "text",
+                    required: false,
+                },
+                {
+                    name: "type",
+                    code: "type",
+                    columnName: "type",
+                    type: "text",
+                    required: true,
+                },
+                {
+                    name: "method",
+                    code: "method",
+                    columnName: "method",
+                    type: "text",
+                    required: true,
+                },
+                {
+                    name: "endpoint",
+                    code: "endpoint",
+                    columnName: "endpoint",
+                    type: "text",
+                    required: true,
+                },
+                {
+                    name: "handlers",
+                    code: "handlers",
+                    columnName: "handlers",
+                    type: "json",
+                    required: true,
+                },
+            ],
+        },
+    ],
+    routes: [
+        {
+            namespace: "meta",
+            name: "meta.model.list",
+            code: "meta.model.list",
+            type: "RESTful",
+            method: "get",
+            endpoint: "/meta/models",
+            handlers: [
+                {
+                    code: "listMetaModels",
+                },
+            ],
+        },
+        {
+            namespace: "meta",
+            name: "meta.model.getDetail",
+            code: "meta.model.getDetail",
+            type: "RESTful",
+            method: "get",
+            endpoint: "/meta/models/:namespace/:singularCode",
+            handlers: [
+                {
+                    code: "getMetaModelDetail",
+                },
+            ],
+        },
+        {
+            namespace: "meta",
+            name: "meta.route.list",
+            code: "meta.route.list",
+            type: "RESTful",
+            method: "get",
+            endpoint: "/meta/routes",
+            handlers: [
+                {
+                    code: "listMetaRoutes",
+                },
+            ],
+        },
+    ],
+};
+
+var bootstrapApplicationConfig$1 = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  'default': bootstrapApplicationConfig
+});
+
+fixBigIntJSONSerialize();
+
+exports.GlobalRequest = GlobalRequest;
+exports.RapidRequest = RapidRequest;
+exports.RouteContext = RouteContext;
+exports.RpdServer = server;
+exports.bootstrapApplicationConfig = bootstrapApplicationConfig$1;