hola-server 1.0.11 → 3.0.0

package/dist/db/entity.js

@@ -0,0 +1,671 @@
+/**
+ * Entity-level CRUD helpers and metadata-driven operations.
+ * @module db/entity
+ */
+import { SUCCESS, ERROR, NO_PARAMS, INVALID_PARAMS, DUPLICATE_UNIQUE, NOT_FOUND, REF_NOT_FOUND, REF_NOT_UNIQUE, HAS_REF } from "../http/code.js";
+import { validate_required_fields, has_value } from "../core/validate.js";
+import { convert_type, convert_update_type, get_type } from "../core/type.js";
+import { get_entity_meta, DELETE_MODE, filter_fields_by_role } from "../core/meta.js";
+import { unique, map_array_to_obj } from "../core/array.js";
+import { LOG_ENTITY, get_db, oid_query, oid_queries, log_debug, log_error, bulk_update } from "./db.js";
+// Comparison operator mapping for search queries
+const COMPARISON_OPERATORS = [
+    { prefix: ">=", op: "$gte", len: 2 },
+    { prefix: "<=", op: "$lte", len: 2 },
+    { prefix: ">", op: "$gt", len: 1 },
+    { prefix: "<", op: "$lt", len: 1 },
+];
+// Numeric types where "0" should be treated as "no search value" (default empty state)
+// Note: int_enum types are NOT included here because 0 is often a valid enum value (e.g., ACTIVE, ADMIN)
+const NUMERIC_TYPES = ["number", "int", "uint", "float", "ufloat", "decimal", "percentage", "currency"];
+/** Check if a search value should be included in the query */
+const has_search_value = (value, type_name) => {
+    if (!has_value(value))
+        return false;
+    // For numeric types (but not enums), "0" or 0 without comparison operators means no search value
+    if (NUMERIC_TYPES.includes(type_name)) {
+        const raw = `${value}`.trim();
+        // Include if it has comparison operators or is not just "0"
+        if (raw === "0")
+            return false;
+    }
+    return true;
+};
+/** Convert search value type, keeping original on error. */
+const convert_search_value = (type_name, search_value) => {
+    const { value, err } = get_type(type_name).convert(search_value);
+    return err ? search_value : value;
+};
+/** Create search object based on field type and value. */
+const parse_search_value = (name, type_name, search_value) => {
+    const raw = `${search_value}`;
+    if (raw.includes(",")) {
+        const values = raw.split(",").map((v) => convert_search_value(type_name, v));
+        const op = type_name === "array" ? "$all" : "$in";
+        return { [name]: { [op]: values } };
+    }
+    for (const { prefix, op, len } of COMPARISON_OPERATORS) {
+        if (raw.startsWith(prefix)) {
+            return { [name]: { [op]: convert_search_value(type_name, raw.substring(len)) } };
+        }
+    }
+    if (type_name === "array")
+        return { [name]: { $in: [raw] } };
+    let value = convert_search_value(type_name, raw);
+    if (typeof value === "string")
+        value = new RegExp(value, "i");
+    return { [name]: value };
+};
+/** Apply ref_filter to query based on entity context. */
+const apply_ref_filter = (query, ref_filter, ref_by_entity) => {
+    if (!ref_filter)
+        return query;
+    const filter = (ref_by_entity && ref_filter[ref_by_entity]) || ref_filter["*"] || (typeof ref_filter === "object" ? ref_filter : null);
+    return filter ? { ...query, ...filter } : query;
+};
+/** Log error with formatted message. */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const log_err = (msg, data = {}) => {
+    const parts = Object.entries(data)
+        .filter(([, v]) => v !== undefined)
+        .map(([k, v]) => `${k}:${JSON.stringify(v)}`);
+    log_error(LOG_ENTITY, parts.length ? `${msg} - ${parts.join(", ")}` : msg);
+};
+/** Execute a lifecycle hook and return error result if failed. */
+const run_hook = async (hook, hook_name, ctx) => {
+    if (!hook)
+        return null;
+    const { code, err } = await hook(ctx);
+    if (err || code !== SUCCESS) {
+        log_err(`${hook_name} error`, { err, code });
+        return { code, err };
+    }
+    return null;
+};
+/** Validate reference and return error result if failed. */
+const validate_refs = async (entity, obj) => {
+    if (!entity.meta.ref_fields)
+        return null;
+    const { code, err } = await entity.validate_ref(obj);
+    if (err || code !== SUCCESS) {
+        log_err("validate_ref error", { err, code });
+        return { code, err };
+    }
+    return null;
+};
+/** Parse positive integer with default. */
+const parse_int = (value, defaultVal) => {
+    const parsed = parseInt(String(value));
+    return isNaN(parsed) || parsed <= 0 ? defaultVal : parsed;
+};
+/** Extract ref and link fields from field map. */
+const extract_field_info = (fields_map, attr_names, allowed_names) => {
+    const attrs = { _id: 1 };
+    const ref_fields = [];
+    const link_fields = [];
+    attr_names.split(",").forEach((attr) => {
+        if (!allowed_names.includes(attr))
+            return;
+        attrs[attr] = 1;
+        const field = fields_map[attr];
+        if (field.link) {
+            link_fields.push(field);
+            attrs[field.link] = 1;
+        }
+        else if (field.ref) {
+            ref_fields.push(field);
+        }
+    });
+    return { attrs, ref_fields, link_fields };
+};
+export class Entity {
+    meta;
+    _db = null;
+    constructor(meta) {
+        this.meta = get_entity_meta(meta);
+    }
+    /** Get db instance lazily - ensures connection is established */
+    get db() {
+        if (!this._db) {
+            this._db = get_db();
+        }
+        return this._db;
+    }
+    col() {
+        return this.db.col(this.meta.collection);
+    }
+    async bulk_update(items, attrs) {
+        await bulk_update(this.col(), items, attrs);
+    }
+    async validate_ref(param_obj) {
+        const ref_fields = this.meta.ref_fields;
+        if (!ref_fields)
+            return { code: SUCCESS };
+        for (const field of ref_fields) {
+            const value = param_obj[field.name];
+            const ref_entity = new Entity(field.ref);
+            const resolve_ref = async (v) => {
+                const refs = await ref_entity.find_by_ref_value(v, { _id: 1 }, this.meta.collection);
+                if (refs.length === 0)
+                    return { code: REF_NOT_FOUND, err: [field.name] };
+                if (refs.length > 1)
+                    return { code: REF_NOT_UNIQUE, err: [field.name] };
+                return { id: `${refs[0]._id}` };
+            };
+            if (Array.isArray(value)) {
+                const ids = [];
+                for (const v of value) {
+                    const result = await resolve_ref(v);
+                    if (result.code)
+                        return result;
+                    ids.push(result.id);
+                }
+                param_obj[field.name] = ids;
+            }
+            else if (has_value(value)) {
+                const result = await resolve_ref(value);
+                if (result.code)
+                    return result;
+                param_obj[field.name] = result.id;
+            }
+        }
+        return { code: SUCCESS };
+    }
+    async get_search_query(param_obj) {
+        const { search_fields } = this.meta;
+        if (!search_fields?.length)
+            return null;
+        // Warn about filter values for non-searchable fields (common mistake: search:false but expecting filter to work)
+        const searchable_names = new Set(search_fields.map((f) => f.name));
+        const all_field_names = new Set(this.meta.fields.map((f) => f.name));
+        for (const [key, value] of Object.entries(param_obj)) {
+            if (key.startsWith("_"))
+                continue; // Skip system params like _id, _user
+            if (!all_field_names.has(key))
+                continue; // Skip unknown fields
+            if (!searchable_names.has(key) && has_value(value)) {
+                log_error(LOG_ENTITY, `Filter ignored: field '${key}' has search:false in entity '${this.meta.collection}'. Set search:true to enable filtering.`);
+            }
+        }
+        const ref_names = this.meta.ref_fields.map((f) => f.name);
+        const and_array = [];
+        for (const field of search_fields) {
+            const value = param_obj[field.name];
+            const type_name = field.type || "string";
+            if (!has_search_value(value, type_name))
+                continue;
+            if (ref_names.includes(field.name)) {
+                const ref_entity = new Entity(field.ref);
+                const oids = await ref_entity.find_by_ref_value(value, { _id: 1 }, this.meta.collection);
+                if (oids.length > 0) {
+                    const ids = oids.map((o) => `${o._id}`);
+                    const op = oids.length === 1 ? null : `${value}`.includes(",") ? "$all" : "$in";
+                    and_array.push(op ? { [field.name]: { [op]: ids } } : { [field.name]: ids[0] });
+                }
+            }
+            else {
+                and_array.push(parse_search_value(field.name, field.type || "string", value));
+            }
+        }
+        const id_param = param_obj._id?.trim();
+        if (id_param) {
+            const ids = id_param.split(",");
+            and_array.push(ids.length === 1 ? oid_query(ids[0]) : oid_queries(ids));
+        }
+        if (and_array.length > 0) {
+            const query = { $and: and_array };
+            log_debug(LOG_ENTITY, `search query:${JSON.stringify(query)}`);
+            return query;
+        }
+        return {};
+    }
+    async list_entity(query_params, query, param_obj, role) {
+        const { attr_names, page, limit, sort_by, desc } = query_params;
+        const sorts = sort_by.split(",");
+        const descs = desc.split(",");
+        const sort = sorts.reduce((s, field, i) => ({ ...s, [field]: descs[i] === "false" ? 1 : -1 }), {});
+        const list_fields = filter_fields_by_role(this.meta.list_fields, role);
+        const { attrs, ref_fields, link_fields } = extract_field_info(this.meta.fields_map, attr_names, list_fields.map((f) => f.name));
+        const search_query = await this.get_search_query(param_obj);
+        if (search_query === null) {
+            log_err("no search query", { param_obj });
+            return { code: INVALID_PARAMS, err: "no search query is set" };
+        }
+        const merged = { ...(query || {}), ...search_query };
+        const total = await this.count(merged);
+        const list = await this.find_page(merged, sort, page, limit, attrs);
+        const with_links = await this.read_link_attrs(list, link_fields);
+        const data = await this.convert_ref_attrs(with_links, ref_fields);
+        log_debug(LOG_ENTITY, `total:${total},data:${JSON.stringify(data)}`);
+        return { code: SUCCESS, total, data };
+    }
+    async _save_entity(param_obj, role, options) {
+        const { fields_key, before_hook, main_hook, after_hook, id_for_hook } = options;
+        const def = this.meta;
+        const fields = filter_fields_by_role(this.meta[fields_key], role);
+        const { obj, error_field_names } = convert_update_type(param_obj, fields);
+        if (error_field_names.length > 0) {
+            log_err("invalid fields", { fields: error_field_names });
+            return { code: INVALID_PARAMS, err: error_field_names };
+        }
+        // Preserve _user context for hooks to access (e.g., for setting ownership fields)
+        if (param_obj._user) {
+            obj._user = param_obj._user;
+            // Auto-set user_field from session user (works even if field has create: false)
+            if (this.meta.user_field && param_obj._user.sub) {
+                obj[this.meta.user_field] = param_obj._user.sub;
+            }
+        }
+        // Build hook context based on whether we have an id (clone) or not (create)
+        const hookCtx = id_for_hook ? { id: id_for_hook, entity: this, data: obj } : { entity: this, data: obj };
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const before_err = await run_hook(def[before_hook], before_hook, hookCtx);
+        if (before_err)
+            return before_err;
+        const missing = validate_required_fields(obj, this.meta.required_field_names);
+        if (missing.length > 0) {
+            log_err("missing required fields", { fields: missing });
+            return { code: NO_PARAMS, err: missing };
+        }
+        if ((await this.count_by_primary_keys(obj)) > 0) {
+            return { code: DUPLICATE_UNIQUE, err: "entity already exist in db" };
+        }
+        const ref_err = await validate_refs(this, obj);
+        if (ref_err)
+            return ref_err;
+        if (def[main_hook]) {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const main_err = await run_hook(def[main_hook], main_hook, hookCtx);
+            if (main_err)
+                return main_err;
+        }
+        else {
+            // Clean up _user context before saving to DB
+            delete obj._user;
+            const db_obj = await this.create(obj);
+            if (!db_obj._id) {
+                log_err("create failed");
+                return { code: ERROR, err: "creating record is failed" };
+            }
+        }
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const after_err = await run_hook(def[after_hook], after_hook, hookCtx);
+        if (after_err)
+            return after_err;
+        return { code: SUCCESS };
+    }
+    async create_entity(param_obj, role) {
+        return this._save_entity(param_obj, role, { fields_key: "create_fields", before_hook: "before_create", main_hook: "create", after_hook: "after_create" });
+    }
+    async clone_entity(_id, param_obj, role) {
+        return this._save_entity(param_obj, role, { fields_key: "clone_fields", before_hook: "before_clone", main_hook: "clone", after_hook: "after_clone", id_for_hook: _id });
+    }
+    async update_entity(_id, param_obj, role) {
+        const fields = filter_fields_by_role(this.meta.update_fields, role);
+        const { obj, error_field_names } = convert_update_type(param_obj, fields);
+        if (error_field_names.length > 0) {
+            log_err("update_entity invalid fields", { fields: error_field_names });
+            return { code: INVALID_PARAMS, err: error_field_names };
+        }
+        const updateCtx = { id: _id, entity: this, data: obj };
+        const before_err = await run_hook(this.meta.before_update, "before_update", updateCtx);
+        if (before_err)
+            return before_err;
+        const query = _id ? oid_query(_id) : this.primary_key_query(obj);
+        if (!query) {
+            log_err("invalid query", { _id, obj });
+            return { code: INVALID_PARAMS, err: _id ? ["_id"] : this.meta.primary_keys };
+        }
+        if ((await this.count(query)) !== 1) {
+            log_err("entity not found", { query });
+            return { code: NOT_FOUND, err: _id ? ["_id"] : this.meta.primary_keys };
+        }
+        const ref_err = await validate_refs(this, obj);
+        if (ref_err)
+            return ref_err;
+        if (this.meta.update) {
+            const update_err = await run_hook(this.meta.update, "update", updateCtx);
+            if (update_err)
+                return update_err;
+        }
+        else {
+            await this.update(query, obj);
+        }
+        const after_err = await run_hook(this.meta.after_update, "after_update", updateCtx);
+        if (after_err)
+            return after_err;
+        return { code: SUCCESS };
+    }
+    async batch_update_entity(_ids, param_obj, role) {
+        const fields = filter_fields_by_role(this.meta.update_fields, role);
+        const { obj, error_field_names } = convert_update_type(param_obj, fields);
+        if (error_field_names.length > 0) {
+            log_err("batch_update invalid fields", { fields: error_field_names });
+            return { code: INVALID_PARAMS, err: error_field_names };
+        }
+        const query = oid_queries(_ids);
+        if (!query) {
+            log_err("batch_update invalid ids", { _ids });
+            return { code: INVALID_PARAMS, err: ["_ids"] };
+        }
+        const ref_err = await validate_refs(this, obj);
+        if (ref_err)
+            return ref_err;
+        const batchCtx = { ids: _ids, entity: this, data: obj };
+        if (this.meta.batch_update) {
+            const batch_err = await run_hook(this.meta.batch_update, "batch_update", batchCtx);
+            if (batch_err)
+                return batch_err;
+        }
+        else {
+            const result = await this.update(query, obj);
+            if (result.ok !== 1) {
+                log_err("batch update failed", { query, obj, result });
+                return { code: ERROR, err: "batch update record is failed" };
+            }
+        }
+        const after_err = await run_hook(this.meta.after_batch_update, "after_batch_update", batchCtx);
+        if (after_err)
+            return after_err;
+        return { code: SUCCESS };
+    }
+    async delete_entity(id_array) {
+        const query = oid_queries(id_array);
+        if (!query) {
+            log_err("delete_entity invalid ids", { id_array });
+            return { code: INVALID_PARAMS, err: ["ids"] };
+        }
+        const deleteCtx = { entity: this, ids: id_array };
+        const before_err = await run_hook(this.meta.before_delete, "before_delete", deleteCtx);
+        if (before_err)
+            return before_err;
+        if (this.meta.delete) {
+            const delete_err = await run_hook(this.meta.delete, "delete", deleteCtx);
+            if (delete_err)
+                return delete_err;
+        }
+        else {
+            const refs = await this.check_refer_entity(id_array);
+            if (refs.length > 0) {
+                const unique_refs = [...new Set(refs)];
+                log_err("has references", { refs: unique_refs });
+                return { code: HAS_REF, err: unique_refs };
+            }
+            await this.delete(query);
+            for (const ref_by_meta of this.meta.ref_by_metas) {
+                const ref_fields = ref_by_meta.ref_fields.filter((f) => f.ref === this.meta.collection);
+                for (const field of ref_fields) {
+                    if (field.delete === DELETE_MODE.cascade) {
+                        const ref_entity = new Entity(ref_by_meta.collection);
+                        await ref_entity.delete_refer_entity(field.name, id_array);
+                    }
+                }
+            }
+        }
+        const after_err = await run_hook(this.meta.after_delete, "after_delete", deleteCtx);
+        if (after_err)
+            return after_err;
+        return { code: SUCCESS };
+    }
+    async read_property(_id, attr_names, role) {
+        const query = oid_query(_id);
+        if (!query) {
+            log_err("read_property invalid id", { _id });
+            return { code: INVALID_PARAMS, err: ["_id"] };
+        }
+        const property_fields = filter_fields_by_role(this.meta.property_fields, role);
+        const field_names = property_fields.map((f) => f.name);
+        const attrs = { _id: 1 };
+        attr_names.split(",").forEach((attr) => {
+            if (field_names.includes(attr))
+                attrs[attr] = 1;
+        });
+        const results = await this.find(query, attrs);
+        if (results?.length === 1) {
+            log_debug(LOG_ENTITY, `read_property query:${JSON.stringify(query)},result:${JSON.stringify(results[0])}`);
+            return { code: SUCCESS, data: results[0] };
+        }
+        return { code: NOT_FOUND, err: ["_id"] };
+    }
+    async read_entity(_id, attr_names, role) {
+        const query = oid_query(_id);
+        if (!query) {
+            log_err("read_entity invalid id", { _id });
+            return { code: INVALID_PARAMS, err: ["_id"] };
+        }
+        if (!attr_names) {
+            log_err("read_entity invalid attr_names", { attr_names });
+            return { code: INVALID_PARAMS, err: ["attr_names"] };
+        }
+        const property_fields = filter_fields_by_role(this.meta.property_fields, role);
+        const { attrs, ref_fields, link_fields } = extract_field_info(this.meta.fields_map, attr_names, property_fields.map((f) => f.name));
+        const results = await this.find(query, attrs);
+        if (results?.length !== 1)
+            return { code: NOT_FOUND, err: ["_id"] };
+        const readCtx = { id: _id, entity: this, attrNames: attr_names, result: results[0] };
+        const after_err = await run_hook(this.meta.after_read, "after_read", readCtx);
+        if (after_err)
+            return after_err;
+        const with_links = await this.read_link_attrs(results, link_fields);
+        const converted = await this.convert_ref_attrs(with_links, ref_fields);
+        if (converted?.length === 1) {
+            log_debug(LOG_ENTITY, `read_entity query:${JSON.stringify(query)},result:${JSON.stringify(converted[0])}`);
+            return { code: SUCCESS, data: converted[0] };
+        }
+        return { code: NOT_FOUND, err: ["_id"] };
+    }
+    primary_key_query(param_obj) {
+        if (!this.meta.primary_keys.every((key) => has_value(param_obj[key])))
+            return null;
+        const { obj, error_field_names } = convert_type(param_obj, this.meta.primary_key_fields);
+        if (error_field_names.length > 0)
+            return null;
+        return this.meta.primary_keys.reduce((q, key) => ({ ...q, [key]: obj[key] }), {});
+    }
+    count_by_primary_keys(obj) {
+        return this.count(this.primary_key_query(obj));
+    }
+    // Database operations
+    create(obj) {
+        return this.db.create(this.meta.collection, obj);
+    }
+    update(query, obj) {
+        return this.db.update(this.meta.collection, query, obj);
+    }
+    delete(query) {
+        return this.db.delete(this.meta.collection, query);
+    }
+    find(query, attr) {
+        return this.db.find(this.meta.collection, query, attr);
+    }
+    find_one(query, attr) {
+        return this.db.find_one(this.meta.collection, query, attr);
+    }
+    find_sort(query, sort, attr) {
+        return this.db.find_sort(this.meta.collection, query, sort, attr);
+    }
+    find_page(query, sort, page, limit, attr) {
+        return this.db.find_page(this.meta.collection, query, sort, page, limit, attr);
+    }
+    count(query) {
+        return this.db.count(this.meta.collection, query);
+    }
+    sum(query, field) {
+        return this.db.sum(this.meta.collection, query, field);
+    }
+    pull(query, ele) {
+        return this.db.pull(this.meta.collection, query, ele);
+    }
+    push(query, ele) {
+        return this.db.push(this.meta.collection, query, ele);
+    }
+    add_to_set(query, ele) {
+        return this.db.add_to_set(this.meta.collection, query, ele);
+    }
+    delete_by_id(id) {
+        const query = Array.isArray(id) ? oid_queries(id) : oid_query(id);
+        return this.db.delete(this.meta.collection, query);
+    }
+    find_by_ref_value(value, attr, ref_by_entity) {
+        let query = Array.isArray(value) ? oid_queries(value) : oid_query(value);
+        if (!query) {
+            const ref_label = this.meta.ref_label;
+            if (Array.isArray(value)) {
+                query = { [ref_label]: { $in: value } };
+            }
+            else if (String(value).includes(",")) {
+                query = { [ref_label]: { $in: String(value).split(",") } };
+            }
+            else {
+                query = { [ref_label]: value };
+            }
+        }
+        return this.find(apply_ref_filter(query, this.meta.ref_filter, ref_by_entity), attr);
+    }
+    async check_refer_entity(id_array) {
+        const refs = [];
+        for (const ref_by_meta of this.meta.ref_by_metas) {
+            const ref_entity = new Entity(ref_by_meta.collection);
+            const ref_fields = ref_by_meta.ref_fields.filter((f) => f.ref === this.meta.collection);
+            for (const field of ref_fields) {
+                if (field.delete === DELETE_MODE.keep)
+                    continue;
+                const attr = ref_by_meta.ref_label ? { [ref_by_meta.ref_label]: 1 } : {};
+                const entities = await ref_entity.get_refer_entities(field.name, id_array, attr);
+                if (!entities?.length)
+                    continue;
+                if (field.delete === DELETE_MODE.cascade) {
+                    const cascade_refs = await ref_entity.check_refer_entity(entities.map((o) => `${o._id}`));
+                    if (cascade_refs?.length)
+                        refs.push(...cascade_refs);
+                }
+                else {
+                    const label_key = ref_by_meta.ref_label || "_id";
+                    refs.push(...entities.map((o) => `${this.meta.collection}<-${ref_by_meta.collection}:${o[label_key]}`));
+                }
+            }
+        }
+        return refs;
+    }
+    async get_refer_entities(field_name, id_array, attr) {
+        return this.find({ [field_name]: { $in: id_array } }, attr);
+    }
+    async delete_refer_entity(field_name, id_array) {
+        const entities = await this.get_refer_entities(field_name, id_array, {});
+        await this.delete_entity(entities.map((o) => `${o._id}`));
+    }
+    async convert_ref_attrs(elements, ref_fields = this.meta.ref_fields) {
+        if (!elements?.length || !ref_fields?.length)
+            return elements;
+        for (const field of ref_fields) {
+            let ids = [];
+            for (const obj of elements) {
+                const value = obj[field.name];
+                if (Array.isArray(value))
+                    ids.push(...value);
+                else if (value)
+                    ids.push(value);
+            }
+            ids = unique(ids);
+            const ref_entity = new Entity(field.ref);
+            const labels = await ref_entity.get_ref_labels(ids);
+            const label_map = map_array_to_obj(labels, "_id", ref_entity.meta.ref_label);
+            for (const obj of elements) {
+                const value = obj[field.name];
+                obj[`${field.name}_id`] = value;
+                obj[field.name] = Array.isArray(value) ? value.map((v) => label_map[v]) : value ? label_map[value] : value;
+            }
+        }
+        return elements;
+    }
+    async read_link_attrs(elements, link_fields) {
+        if (!elements?.length || !link_fields?.length)
+            return elements;
+        const entity_info = {};
+        for (const field of link_fields) {
+            const link_field = this.meta.fields_map[field.link];
+            const entity = link_field.ref;
+            if (!entity_info[entity])
+                entity_info[entity] = { attrs: [], filters: [] };
+            entity_info[entity].attrs.push(field.name);
+            if (!entity_info[entity].filters.includes(link_field.name)) {
+                entity_info[entity].filters.push(link_field.name);
+            }
+        }
+        for (const [entity_name, { attrs, filters }] of Object.entries(entity_info)) {
+            const entity = new Entity(entity_name);
+            const ids = unique(elements.flatMap((o) => filters.map((f) => o[f])).filter(Boolean));
+            const query = oid_queries(ids);
+            if (!query)
+                continue;
+            const attr_obj = {};
+            const ref_fields = [];
+            for (const attr of attrs) {
+                attr_obj[attr] = 1;
+                const field = entity.meta.fields_map[attr];
+                if (!field.link && field.ref)
+                    ref_fields.push(field);
+            }
+            const items = await entity.find(query, attr_obj);
+            if (!items?.length)
+                continue;
+            await entity.convert_ref_attrs(items, ref_fields);
+            for (let i = 0; i < elements.length; i++) {
+                for (const filter of filters) {
+                    const id = elements[i][filter];
+                    const link_item = items.find((o) => `${o._id}` === `${id}`);
+                    if (link_item) {
+                        const { _id, ...data } = link_item;
+                        elements[i] = { ...elements[i], ...data };
+                    }
+                }
+            }
+        }
+        return elements;
+    }
+    get_filtered_ref_labels(ref_by_entity, client_query, user_id) {
+        let query = {};
+        if (this.meta.user_field && user_id)
+            query[this.meta.user_field] = user_id;
+        let search_query = {};
+        if (client_query?.trim() && this.meta.search_fields?.length) {
+            for (const part of client_query.split(",")) {
+                const [field_name, value] = part.split(":");
+                if (field_name && value) {
+                    const field = this.meta.search_fields.find((f) => f.name === field_name);
+                    if (field)
+                        search_query = parse_search_value(field_name, field.type || "string", value);
+                }
+            }
+        }
+        query = apply_ref_filter(query, this.meta.ref_filter, ref_by_entity);
+        const ref_label = this.meta.ref_label;
+        return this.find_sort({ ...search_query, ...query }, { [ref_label]: 1 }, { [ref_label]: 1 });
+    }
+    get_ref_labels(id_array) {
+        return this.find(oid_queries(id_array), { [this.meta.ref_label]: 1 });
+    }
+    find_by_oid(id, attr) {
+        const query = oid_query(id);
+        return query ? this.find_one(query, attr) : Promise.resolve(null);
+    }
+    find_one_ref_entity(field_name, value, attr) {
+        const field = this.meta.fields.find((f) => f.name === field_name);
+        if (!field) {
+            throw new Error(`field not found: ${field_name} in ${this.meta.collection}`);
+        }
+        if (!field.ref) {
+            throw new Error(`field is not ref: ${field_name} in ${this.meta.collection}`);
+        }
+        const ref_entity = new Entity(field.ref);
+        const query = oid_query(value) || { [ref_entity.meta.ref_label]: value };
+        return ref_entity.find_one(query, attr);
+    }
+    oid_query(_id) {
+        return oid_query(_id);
+    }
+    oid_queries(_ids) {
+        return oid_queries(_ids);
+    }
+}
+//# sourceMappingURL=entity.js.map