spice-js 2.7.18 → 2.7.19

package/src/models/SpiceModel.js.bak

@@ -1,2186 +0,0 @@
-"use strict";
-
-import { MapType, DataType } from "..";
-let co = require("co");
-var regeneratorRuntime = require("regenerator-runtime");
-import ResourceLifecycleTriggered from "../events/events/ResourceLifecycleTriggered";
-import { hasSQLInjection } from "../utility/Security";
-import { fixCollection } from "../utility/fix";
-
-var SDate = require("sonover-date"),
-  UUID = require("uuid"),
-  _ = require("lodash"),
-  _database = Symbol(),
-  _ctx = Symbol(),
-  _props = Symbol(),
-  _args = Symbol(),
-  _hooks = Symbol(),
-  _columns = Symbol(),
-  _disable_lifecycle_events = Symbol(),
-  _external_modifier_loaded = Symbol(),
-  _skip_cache = Symbol(),
-  _serializers = Symbol(),
-  _level = Symbol(),
-  _mapping_dept = Symbol(),
-  _mapping_dept_exempt = Symbol(),
-  _current_path = Symbol();
-
-//const _type = Symbol("type");
-
-// Helper to resolve spice global (for testing compatibility)
-// In production, spice is injected globally. In tests, we need to access it via global.
-function getSpice() {
-  if (typeof spice !== 'undefined') {
-    return spice;
-  }
-  if (typeof global !== 'undefined' && global.spice) {
-    return global.spice;
-  }
-  if (typeof globalThis !== 'undefined' && globalThis.spice) {
-    return globalThis.spice;
-  }
-  throw new Error('spice global not found');
-}
-
-let that;
-if (!Promise.allSettled) {
-  Promise.allSettled = (promises) =>
-    Promise.all(
-      promises.map((promise, i) =>
-        promise
-          .then((value) => ({
-            status: "fulfilled",
-            value,
-          }))
-          .catch((reason) => ({
-            status: "rejected",
-            reason,
-          })),
-      ),
-    );
-}
-export default class SpiceModel {
-  constructor(args = {}) {
-    try {
-      var dbtype =
-        spice.config.database.connections[args.connection].type || "couchbase";
-      let Database = require(`spice-${dbtype}`);
-      this[_mapping_dept] =
-        args?.args?.mapping_dept || process.env.MAPPING_DEPT || 3;
-      this[_mapping_dept_exempt] = args?.args?.mapping_dept_exempt || [];
-      this.type = "";
-      this.collection = args.connection;
-      this[_args] = args.args;
-      this[_external_modifier_loaded] = false;
-      this[_disable_lifecycle_events] =
-        args.args?.disable_lifecycle_events || false;
-      this[_ctx] = args?.args?.ctx;
-      this[_skip_cache] = args?.args?.skip_cache || false;
-      this[_level] = args?.args?._level || 0;
-      this[_current_path] = args?.args?._current_path || "";
-      this[_columns] = args?.args?._columns || "";
-      this[_hooks] = {
-        create: {
-          before: [],
-          after: [],
-        },
-        get: {
-          before: [],
-          after: [],
-        },
-        list: {
-          before: [],
-          after: [],
-        },
-        update: {
-          before: [],
-          after: [],
-        },
-        delete: {
-          before: [],
-          after: [],
-        },
-      };
-      this[_serializers] = {
-        read: {
-          modifiers: [],
-          cleaners: ["deleted", "type"],
-        },
-        write: {
-          modifiers: [],
-          cleaners: [],
-        },
-      };
-
-      this.deleted = false;
-      this[_database] = new Database(args.connection || "default", {
-        collection: args.collection,
-        scope: args.scope,
-      });
-
-      function removeDynamicProps(props) {
-        let returnVal = {};
-        for (let i in props) {
-          if (
-            !_.has(props[i], "source") ||
-            _.get(props[i], "source") == "static"
-          ) {
-            returnVal[i] = props[i];
-          }
-        }
-        return returnVal;
-      }
-
-      function applySchemaOverrides(props, resource) {
-        spice.schema_extenders = spice.schema_extenders || [];
-
-        function applyExtenderModifier(prop, resource, extender) {
-          if (extender.modifier) {
-            return extender.modifier(prop, resource);
-          }
-          return prop;
-        }
-
-        function hasExtender(resource, prop, extender) {
-          if (extender.selector(prop, resource)) {
-            return true;
-          }
-          return false;
-        }
-
-        function resourceHasExtender(resource, extender) {
-          return (
-            extender.resource.includes(resource) ||
-            extender.resource.includes("*")
-          );
-        }
-
-        for (let file_name in spice.schema_extenders) {
-          let extender = spice.schema_extenders[file_name];
-          if (resourceHasExtender(resource, extender)) {
-            for (let j in props) {
-              if (hasExtender(resource, props[j], extender)) {
-                props[j] = applyExtenderModifier(props[j], resource, extender);
-              }
-            }
-            if (extender?.creator) {
-              props = _.merge(props, extender.creator(resource));
-            }
-          }
-        }
-        return props;
-      }
-      args.props = applySchemaOverrides(
-        removeDynamicProps(args.props),
-        args.collection,
-      );
-      this[_props] = args.props;
-
-      // Get dynamic schema for zero-downtime field updates
-      // Merge with static props to ensure new fields are also copied to instance
-      let effectiveProps = args.props;
-      if (typeof spice !== "undefined" && spice.schemas && args.collection) {
-        const dynamicSchema =
-          spice.schemas[args.collection] ||
-          spice.schemas[args.collection.toLowerCase()];
-        if (dynamicSchema) {
-          effectiveProps = { ...args.props, ...dynamicSchema };
-        }
-      }
-
-      for (let i in effectiveProps) {
-        if (args.args != undefined) {
-          if (args.args[i] != undefined) {
-            const propDef = effectiveProps[i] || {};
-            switch (propDef.type) {
-              case String:
-              case "string": {
-                this[i] = args.args[i];
-                break;
-              }
-              case Number:
-              case "number": {
-                this[i] =
-                  _.isNumber(args.args[i]) ?
-                    args.args[i]
-                  : Number(args.args[i]);
-                break;
-              }
-              case Boolean:
-              case "boolean": {
-                this[i] =
-                  _.isBoolean(args.args[i]) ?
-                    args.args[i]
-                  : args.args[i] == "true" ||
-                    args.args[i] == 1 ||
-                    args.args[i] == "True";
-                break;
-              }
-              case Date:
-              case "date": {
-                this[i] = args.args[i];
-                break;
-              }
-              case Array:
-              case "array": {
-                this[i] =
-                  _.isArray(args.args[i]) ?
-                    args.args[i]
-                  : JSON.parse(args.args[i]);
-                break;
-              }
-              case Object:
-              case "object": {
-                this[i] =
-                  _.isObject(args.args[i]) ?
-                    args.args[i]
-                  : JSON.parse(args.args[i]);
-                break;
-              }
-              default: {
-                this[i] = args.args[i];
-              }
-            }
-          }
-        }
-      }
-      that = this;
-      this.createModifiersFromProps();
-    } catch (e) {
-      console.warn(e.stack);
-    }
-    // }
-  }
-
-  get database() {
-    return this[_database];
-  }
-  set database(value) {
-    this[_database] = value;
-  }
-
-  get props() {
-    // Dynamically look up schema from spice.schemas for zero-downtime updates
-    // Fall back to stored props for backward compatibility
-    if (this.type && typeof spice !== "undefined" && spice.schemas) {
-      const dynamicSchema =
-        spice.schemas[this.type] || spice.schemas[this.type.toLowerCase()];
-      if (dynamicSchema) {
-        return dynamicSchema;
-      }
-    }
-    return this[_props];
-  }
-
-  set props(value) {
-    this[_props] = value;
-  }
-
-  is_date(item) {
-    return item.length > 27 && item.indexOf("|") > -1;
-  }
-
-  async propsToBeRemoved(data) {
-    if (!_.isArray(data)) {
-      data = Array.of(data);
-    }
-
-    if (this[_ctx]) {
-      if (this[_ctx]?.state?.process_fields) {
-        let returned = await new this[_ctx].state.process_fields().process(
-          this[_ctx],
-          data,
-          this.type,
-        );
-        return returned;
-      } else {
-        return data;
-      }
-    }
-    return [];
-  }
-
-  createValidationString({ property_name, props, operation, complete }) {
-    let operationExempt = {
-      PUT: ["required", "unique"],
-    };
-    let returnVal = [];
-    for (let i in props) {
-      if (!_.includes(operationExempt[operation] || [], i) || complete) {
-        if (i == "required" && props[i] == true) {
-          returnVal.push("required");
-        }
-        if (i == "email" && props[i] == true) {
-          returnVal.push("email");
-        }
-        if (i == "json" && props[i] == true) {
-          returnVal.push("json");
-        }
-        if (i == "ip" && props[i] == true) {
-          returnVal.push("ip");
-        }
-        if (i == "url" && props[i] == true) {
-          returnVal.push("url");
-        }
-        if (i == "date" && props[i] == true) {
-          returnVal.push("date");
-        }
-        if (i == "requires") {
-          returnVal.push(`shouldExist:${props[i]}`);
-        }
-        if (i == "unique" && props[i] == true) {
-          returnVal.push(`unique:${this.constructor.name},${property_name}`);
-        }
-        if (i == "type") {
-          switch (props[i]) {
-            case String:
-            case DataType.STRING: {
-              returnVal.push(`string`);
-              break;
-            }
-            case Number:
-            case DataType.NUMBER: {
-              //returnVal.push(`numeric`);
-              break;
-            }
-            case Boolean:
-            case DataType.BOOLEAN: {
-              returnVal.push(`in:true,false,True,False,TRUE,FALSE,1,0`);
-              break;
-            }
-            case Date:
-            case DataType.DATE: {
-              returnVal.push(`date`);
-              break;
-            }
-            case Object:
-            case DataType.OBJECT: {
-              //returnVal.push(`json`);
-              break;
-            }
-            case Array:
-            case DataType.ARRAY: {
-              //returnVal.push(`json`);
-              break;
-            }
-            default: {
-              returnVal.push(`string`);
-              break;
-            }
-          }
-        }
-      }
-    }
-    return _.join(returnVal, "|");
-  }
-
-  createFilterString(property, props) {
-    let returnVal = [];
-    for (let i in props) {
-      if (i == "lowercase" && props[i] == true) {
-        returnVal.push("lowercase");
-      }
-      if (i == "trim" && props[i] == true) {
-        returnVal.push("trim");
-      }
-      if (i == "uppercase" && props[i] == true) {
-        returnVal.push("uppercase");
-      }
-    }
-    return _.join(returnVal, "|");
-  }
-
-  getValidationRules(
-    method = "POST",
-    { complete = false, pick = [], omit = [] } = {},
-  ) {
-    let rules = {};
-    let filters = {};
-    let working_properties = this.props;
-    if (pick.length > 0) {
-      working_properties = _.pick(this.props, pick);
-    }
-
-    if (omit.length > 0) {
-      working_properties = _.omit(this.props, omit);
-    }
-
-    for (let i in working_properties) {
-      let created_rules = this.createValidationString({
-        property_name: i,
-        props: this.props[i],
-        operation: method,
-        complete,
-      });
-      if (created_rules.length > 0) {
-        rules[i] = created_rules;
-      }
-
-      let created_filter = this.createFilterString(i, this.props[i]);
-      if (created_filter.length > 0) {
-        filters[i] = created_filter;
-      }
-    }
-    return { rules, messages: {}, filters: { before: filters } };
-  }
-
-  makeQueryFromFilter(filter) {
-    let return_string = "";
-    for (let key in filter) {
-      let item_string = "";
-      if (filter[key].length > 1) {
-        item_string = "(";
-      }
-
-      let item_count = 0;
-
-      for (let item of filter[key]) {
-        if (item_count > 0) {
-          item_string = item_string + " OR ";
-        }
-
-        if (this.is_date(item)) {
-          let to_index = item.indexOf("|");
-          let first = item.substring(0, to_index);
-          let second = item.substring(to_index + 1, item.length);
-          item_string =
-            item_string +
-            " " +
-            key +
-            " BETWEEN '" +
-            first +
-            "' AND '" +
-            second +
-            "'";
-        } else {
-          item_string = item_string + " " + key + " LIKE '" + item + "'";
-        }
-
-        item_count++;
-      }
-
-      if (filter[key].length > 1) {
-        item_string = item_string + ")";
-      }
-      if (return_string != "") {
-        return_string = return_string + " AND ";
-      }
-      return_string = return_string + item_string;
-    }
-    return return_string;
-  }
-
-  shouldUseCache(resource_type) {
-    // If '_skip_cache' property of this object is true, then we shouldn't cache.
-    if (this[_skip_cache] == true) {
-      return false;
-    }
-
-    // If the system configuration for spice has a cache status set to "disable",
-    // then we shouldn't cache, so return false.
-    if (spice.config.cache?.status == "disabled") {
-      return false;
-    }
-
-    // If 'spice.cache[resource_type]' is not undefined,
-    // it implies that this resource type is already in the cache or is cacheable.
-    return spice.cache[resource_type] != undefined;
-  }
-
-  getCacheConfig(resource_type) {
-    return spice.cache[resource_type] || {};
-  }
-
-  getCacheProviderObject(resource_type) {
-    return spice.cache_providers[
-      this.getCacheConfig(resource_type).driver ||
-        this.getCacheConfig(resource_type).provider ||
-        spice.config.cache.default_driver
-    ];
-  }
-
-  async exists(item_type, key) {
-    let obj = this.getCacheProviderObject(item_type);
-    if (obj) return await obj.exists(key);
-    return false;
-  }
-
-  async shouldForceRefresh(response) {
-    let obj = this.getCacheProviderObject(this.type);
-    let monitor_record = await obj.get(`monitor::${this.type}`);
-    if (monitor_record == undefined) {
-      return false;
-    }
-    if (monitor_record.time > response?.time) {
-      return true;
-    }
-    return false;
-  }
-
-  setMonitor() {
-    let current_time = new Date().getTime();
-    let obj = this.getCacheProviderObject(this.type);
-    let key = `monitor::${this.type}`;
-    let value = { time: current_time };
-    obj.set(key, value, { ttl: 0 });
-  }
-
-  async get(args) {
-    // Profiling: use track() for proper async context forking
-    const p = this[_ctx]?.profiler;
-
-    const doGet = async () => {
-      if (args.mapping_dept) this[_mapping_dept] = args.mapping_dept;
-      if (args.mapping_dept_exempt)
-        this[_mapping_dept_exempt] = args.mapping_dept_exempt;
-
-      if (!args) {
-        args = {};
-      }
-      if (_.isString(args.id)) {
-        if (args.skip_hooks !== true) {
-          await this.run_hook(args, "get", "before");
-        }
-        // ⚡ Include columns in cache key if specified
-        let key = `get::${this.type}::${args.id}${args.columns ? `::${args.columns}` : ""}`;
-        let results = {};
-
-        // Extract nestings from columns if specified
-        const nestings = this.extractNestings(args?.columns || "", this.type);
-
-        // Build join metadata and prepare columns
-        this.buildJoinMetadata(nestings, args);
-        let columns = args.columns;
-        let columnArray = [];
-        if (columns) {
-          columns.split(",").forEach((col) => {
-            const parts = col.trim().split("."); // remove the first segment
-            // Also match if parts[0] is source_property or '`' + source_property + '`'
-            const firstPart = parts[0];
-            // Remove backticks if present
-            const cleanFirstPart =
-              (
-                firstPart &&
-                firstPart.startsWith("`") &&
-                firstPart.endsWith("`")
-              ) ?
-                firstPart.slice(1, -1)
-              : firstPart;
-
-            //if (parts.length > 0 && (firstPart === source_property || cleanFirstPart === source_property)) {
-            // Use cleanFirstPart for the map key to handle both cases consistently
-            // Remove backticks from each column segment, if present, before joining
-            columnArray.push(
-              parts
-                .slice(1)
-                .map((segment) =>
-                  segment && segment.startsWith("`") && segment.endsWith("`") ?
-                    segment.slice(1, -1)
-                  : segment,
-                )
-                .join("."),
-            );
-            // }
-          });
-        }
-
-        if (this.shouldUseCache(this.type)) {
-          // Retrieve the cached results
-          const cached_results = await this.getCacheProviderObject(
-            this.type,
-          ).get(key);
-          // Check if the cache is empty
-          const isCacheEmpty = cached_results?.value === undefined;
-          // Check if the cached result should be refreshed
-          const shouldRefresh = await this.shouldForceRefresh(cached_results);
-
-          if (isCacheEmpty || shouldRefresh) {
-            // Retrieve from the database and update cache
-            if (p) {
-              results = await p.track(`${this.type}.get.database`, async () => {
-                return await this.database.get(args.id, {
-                  columns: columnArray,
-                });
-              });
-            } else {
-              results = await this.database.get(args.id, {
-                columns: columnArray,
-              });
-            }
-            await this.getCacheProviderObject(this.type).set(
-              key,
-              { value: results, time: new Date().getTime() },
-              this.getCacheConfig(this.type),
-            );
-          } else {
-            // Use the cached value
-            results = cached_results.value;
-          }
-        } else {
-          // Directly fetch from the database if caching is disabled
-          if (p) {
-            results = await p.track(`${this.type}.get.database`, async () => {
-              return await this.database.get(args.id, { columns: columnArray });
-            });
-          } else {
-            results = await this.database.get(args.id, {
-              columns: columnArray,
-            });
-          }
-        }
-
-        if (results.type !== undefined && results.type !== this.type) {
-          throw new Error(`${this.type} does not exist type`);
-        }
-        if (results._type !== undefined && results._type !== this.type) {
-          throw new Error(`${this.type} does not exist _type`);
-        }
-        if (results.deleted === undefined || results.deleted === false) {
-          if (
-            args.skip_read_serialize !== true &&
-            args.skip_serialize !== true
-          ) {
-            // ⚡ Pass columns to do_serialize so it can skip irrelevant modifiers
-            results = await this.do_serialize(
-              results,
-              "read",
-              {},
-              args,
-              await this.propsToBeRemoved(results),
-            );
-          }
-
-          // ⚡ OPTIMIZED: Filter results by columns if specified
-          if (args.columns) {
-            results = this.filterResultsByColumns([results], args.columns)[0];
-          }
-
-          if (args.skip_hooks !== true) {
-            await this.run_hook(results, "get", "after");
-          }
-          return results;
-        } else {
-          throw new Error(`${this.type} does not exist`);
-        }
-      }
-    };
-
-    try {
-      if (p) {
-        return await p.track(`${this.type}.get`, doGet, { id: args?.id });
-      }
-      return await doGet();
-    } catch (e) {
-      console.warn(e.message, e);
-      throw e;
-    }
-  }
-
-  async query(query, scope) {
-    try {
-      let results = await this.database.query(query, scope);
-      return results;
-    } catch (error) {
-      throw error;
-    }
-  }
-
-  async getMulti(args) {
-    // ⚡ Profiling: use track() for proper async context forking
-    const p = this[_ctx]?.profiler;
-
-    const doGetMulti = async () => {
-      if (!args) {
-        args = {};
-      }
-      if (args.skip_hooks != true) {
-        await this.run_hook(this, "list", "before");
-      }
-      // PATCH: Prevent empty/null IDs from causing query explosions
-      _.remove(args.ids, (o) => o == undefined || o === "" || o === null);
-
-      // PATCH: Early exit if no valid IDs after filtering
-      if (!args.ids || args.ids.length === 0) {
-        return []; // No IDs to fetch
-      }
-
-      let key = `multi-get::${this.type}::${_.join(args.ids, "|")}:${args.columns}`;
-      let results = [];
-      if (args.ids.length > 0) {
-        if (this.shouldUseCache(this.type)) {
-          let cached_results = await this.getCacheProviderObject(this.type).get(
-            key,
-          );
-          results = cached_results?.value;
-          if (
-            cached_results?.value === undefined ||
-            (await this.shouldForceRefresh(cached_results))
-          ) {
-            results = await this.database.multi_get(args.ids, {
-              keep_type: true,
-              columns:
-                args.columns && args.columns.length > 0 && args.columns != "" ?
-                  [...this.extractBaseColumns(args.columns), "type"]
-                : [],
-            });
-            this.getCacheProviderObject(this.type).set(
-              key,
-              { value: results, time: new Date().getTime() },
-              this.getCacheConfig(this.type),
-            );
-          }
-        } else {
-          results = await this.database.multi_get(args.ids, {
-            keep_type: true,
-            columns:
-              args.columns && args.columns.length > 0 && args.columns != "" ?
-                [...this.extractBaseColumns(args.columns), "type"]
-              : [],
-          });
-        }
-      }
-      _.remove(results, (o) => o.type != this.type);
-      if (args.skip_read_serialize != true && args.skip_serialize != true) {
-        results = await this.do_serialize(
-          results,
-          "read",
-          {},
-          args,
-          await this.propsToBeRemoved(results),
-        );
-      }
-
-      if (args.skip_hooks != true) {
-        await this.run_hook(results, "list", "after", args.context);
-      }
-
-      return results;
-    };
-
-    try {
-      if (p) {
-        return await p.track(`${this.type}.getMulti`, doGetMulti, {
-          ids_count: args?.ids?.length || 0,
-        });
-      }
-      return await doGetMulti();
-    } catch (e) {
-      console.warn(e.stack);
-      throw e;
-    }
-  }
-
-  async exist(data) {
-    try {
-      if (_.isString(data)) {
-        let result = await this.database.get(data);
-        if (result.type)
-          if (result.type != this.type) {
-            return false;
-          }
-        if (result._type)
-          if (result._type != this.type) {
-            return false;
-          }
-      } else {
-        if (data.type)
-          if (data.type != this.type) {
-            return false;
-          }
-
-        if (data._type)
-          if (data._type != this.type) {
-            return false;
-          }
-      }
-      return true;
-    } catch (e) {
-      throw e;
-    }
-  }
-
-  async update(args) {
-    // Profiling: use track() for proper async context forking
-    const p = this[_ctx]?.profiler;
-
-    const doUpdate = async () => {
-      this.updated_at = new SDate().now();
-      let results = await this.database.get(args.id);
-      let item_exist = await this.exist(results);
-      if (!item_exist) {
-        throw new Error(`${this.type} does not exist. in update`);
-      }
-      delete results["id"];
-      _.defaults(this, results);
-      let cover_obj = {
-        old: results,
-        new: this,
-        id: args.id,
-      };
-
-      let form;
-      if (args.skip_write_serialize != true && args.skip_serialize != true) {
-        cover_obj.new = await this.do_serialize(
-          this,
-          "write",
-          cover_obj.new,
-          args,
-        );
-      }
-
-      if (args.skip_hooks != true) {
-        await this.run_hook(cover_obj, "update", "before", results);
-      }
-      let db_data = cover_obj.new || this;
-
-      if (p) {
-        await p.track(`${this.type}.update.database`, async () => {
-          await this.database.update(args.id, db_data, args._ttl);
-        });
-      } else {
-        await this.database.update(args.id, db_data, args._ttl);
-      }
-      this.setMonitor();
-
-      if (args.skip_read_serialize != true && args.skip_serialize != true) {
-        cover_obj.new = await this.do_serialize(
-          cover_obj.new,
-          "read",
-          {},
-          args,
-          await this.propsToBeRemoved(cover_obj.new),
-        );
-      }
-
-      if (args.skip_hooks != true) {
-        await this.run_hook(
-          {
-            ...this,
-            id: args.id,
-          },
-          "update",
-          "after",
-          results,
-        );
-      }
-      this.id = args.id;
-      return { ...cover_obj.new, id: args.id };
-    };
-
-    try {
-      if (p) {
-        return await p.track(`${this.type}.update`, doUpdate, { id: args?.id });
-      }
-      return await doUpdate();
-    } catch (e) {
-      console.warn("Error on update", e, e.stack);
-      throw e;
-    }
-  }
-
-  async create(args = {}) {
-    // Profiling: use track() for proper async context forking
-    const p = this[_ctx]?.profiler;
-
-    const doCreate = async () => {
-      let form;
-      this.created_at = new SDate().now();
-      args = _.defaults(args, { id_prefix: this.type });
-      if (args.body) {
-        form = _.defaults({}, args.body);
-        form.created_at = this.created_at;
-        form.updated_at = this.created_at;
-        delete form["bucket"];
-      }
-      let workingForm = form || this;
-      this.updated_at = new SDate().now();
-
-      let id = `${args.id_prefix}-${UUID.v4()}`;
-      if (args && args.id) {
-        id = args.id;
-      }
-
-      if (args.skip_write_serialize != true && args.skip_serialize != true) {
-        workingForm = await this.do_serialize(workingForm, "write", {}, args);
-      }
-
-      if (args.skip_hooks != true) {
-        await this.run_hook(workingForm, "create", "before");
-      }
-
-      let results;
-      if (p) {
-        results = await p.track(`${this.type}.create.database`, async () => {
-          return await this.database.insert(id, workingForm, args._ttl);
-        });
-      } else {
-        results = await this.database.insert(id, workingForm, args._ttl);
-      }
-      this.setMonitor();
-
-      if (args.skip_read_serialize != true && args.skip_serialize != true) {
-        results = await this.do_serialize(
-          results,
-          "read",
-          {},
-          args,
-          await this.propsToBeRemoved(results),
-        );
-      }
-      if (args.skip_hooks != true) {
-        await this.run_hook(
-          {
-            ...results,
-            id,
-          },
-          "create",
-          "after",
-        );
-      }
-      return { ...results, id };
-    };
-
-    try {
-      if (p) {
-        return await p.track(`${this.type}.create`, doCreate);
-      }
-      return await doCreate();
-    } catch (e) {
-      console.warn(e.stack);
-      throw e;
-    }
-  }
-
-  async touch(args) {
-    let item_exist = await this.exist(args.id);
-
-    if (!item_exist) {
-      throw new Error(`${this.type} does not exist.`);
-    }
-    try {
-      let touch_response = {};
-      touch_response = await this.database.touch(args.id, args._ttl);
-      return touch_response;
-    } catch (e) {
-      console.warn(e.stack);
-      throw e;
-    }
-  }
-
-  async delete(args) {
-    // Profiling: use track() for proper async context forking
-    const p = this[_ctx]?.profiler;
-
-    const doDelete = async () => {
-      let item_exist = await this.exist(args.id);
-
-      if (!item_exist) {
-        throw new Error(`${this.type} does not exist.`);
-      }
-      let results = await this.database.get(args.id);
-      if (args.skip_hooks != true) {
-        await this.run_hook(args, "delete", "before");
-      }
-      let delete_response = {};
-
-      const dbOperation = async () => {
-        if (args.hard) {
-          delete_response = await this.database.delete(args.id);
-          this.setMonitor();
-        } else {
-          delete results["id"];
-          results.deleted = true;
-          delete_response = await this.database.update(args.id, results);
-        }
-      };
-
-      if (p) {
-        await p.track(`${this.type}.delete.database`, dbOperation);
-      } else {
-        await dbOperation();
-      }
-
-      if (args.skip_hooks != true) {
-        await this.run_hook(results, "delete", "after", results);
-      }
-      return {};
-    };
-
-    try {
-      if (p) {
-        return await p.track(`${this.type}.delete`, doDelete, { id: args?.id });
-      }
-      return await doDelete();
-    } catch (e) {
-      console.warn(e.stack);
-      throw e;
-    }
-  }
-
-  toString() {
-    JSON.stringify(this);
-  }
-
-  buildArrayProjection(alias, field) {
-    const safeAlias = String(alias).replace(/`/g, "");
-    const safeField = String(field).replace(/`/g, "");
-    return `ARRAY rc.${safeField} FOR rc IN IFMISSINGORNULL(${safeAlias}, []) END AS \`${safeAlias}_${safeField}\``;
-  }
-
-  prepColumns(columns, protectedAliases = [], arrayAliases = []) {
-    if (!columns || columns === "") return columns;
-
-    const q = (s = "") => {
-      const t = (s || "").trim();
-      if (t.startsWith("`") && t.endsWith("`")) return t;
-      return "`" + t.replace(/`/g, "``") + "`";
-    };
-
-    const protectedSet = new Set(protectedAliases);
-    const arraySet = new Set(arrayAliases);
-
-    const tokens = columns.split(",");
-
-    const out = tokens.map((raw) => {
-      let col = (raw || "").trim();
-      if (col === "" || col === "meta().id") return undefined;
-
-      if (/^\s*ARRAY\s+/i.test(col) || /\w+\s*\(/.test(col)) return col;
-
-      const m = col.match(
-        /^\s*`?(\w+)`?\.`?(\w+)`?(?:\s+AS\s+`?([\w]+)`?)?\s*$/i,
-      );
-      if (m) {
-        const alias = m[1];
-        const field = m[2];
-        const explicitAs = m[3];
-
-        // If alias matches this.type, don't prepend again
-        if (alias === this.type) {
-          const qualified = `${q(alias)}.${q(field)}`;
-          return explicitAs ? `${qualified} AS ${q(explicitAs)}` : qualified;
-        }
-
-        // Check if alias has a map - if so, simplify to root column only (raw ID)
-        const prop = this.props[alias];
-        if (prop?.map) {
-          // Return base table qualified root column, ignoring the .field part
-          return `${q(this.type)}.${q(alias)}`;
-        }
-
-        if (arraySet.has(alias)) {
-          let proj = this.buildArrayProjection(alias, field);
-          if (explicitAs && explicitAs !== `${alias}_${field}`) {
-            proj = proj.replace(/AS\s+`[^`]+`$/i, `AS ${q(explicitAs)}`);
-          }
-          return proj;
-        }
-
-        if (protectedSet.has(alias)) {
-          const aliased = `${q(alias)}.${field.startsWith("`") ? field : q(field)}`;
-          return explicitAs ? `${aliased} AS ${q(explicitAs)}` : aliased;
-        }
-
-        const qualified = `${q(this.type)}.${q(alias)}.${q(field)}`;
-        return explicitAs ? `${qualified} AS ${q(explicitAs)}` : qualified;
-      }
-
-      const looksProtected = [...protectedSet].some(
-        (a) =>
-          col === a ||
-          col === q(a) ||
-          col.startsWith(`${a}.`) ||
-          col.startsWith(`${q(a)}.`),
-      );
-
-      if (!looksProtected) {
-        if (!col.includes(".")) {
-          const fieldQuoted = col.startsWith("`") ? col : q(col);
-          return `${q(this.type)}.${fieldQuoted}`;
-        }
-
-        const parts = col.split(".");
-        const safeParts = parts.map((p) => {
-          const t = p.trim();
-          if (t === "" || /\w+\s*\(/.test(t)) return t;
-          return t.startsWith("`") ? t : q(t);
-        });
-        return `${q(this.type)}.${safeParts.join(".")}`;
-      }
-
-      // For protected aliases (joined resources), return the base table's column (IDs)
-      // instead of the joined resource itself. The JOIN is only for WHERE filtering,
-      // and the serializer will map the IDs later.
-      const unquotedCol = col.replace(/`/g, "");
-      if (protectedSet.has(unquotedCol)) {
-        return `${q(this.type)}.${q(unquotedCol)}`;
-      }
-
-      if (!col.includes(".") && !col.startsWith("`")) {
-        return q(col);
-      }
-      return col;
-    });
-
-    // Deduplicate columns (e.g., when multiple mapped dot-notations share the same root)
-    return _.join(_.uniq(_.compact(out)), ",");
-  }
-
-  filterResultsByColumns(data, columns) {
-    if (columns && columns !== "") {
-      // Remove backticks and replace meta().id with id
-      const cleanedColumns = columns
-        .replace(/`/g, "")
-        .replace(/meta\(\)\.id/g, "id");
-
-      // Process each column by splitting on comma and trimming
-      const columnList = cleanedColumns
-        .split(",")
-        .map((col) => col.trim())
-        .filter((col) => col !== "") // PATCH: Remove empty column names
-        .map((col) => {
-          // Check for alias with AS (case-insensitive)
-          const aliasMatch = col.match(/\s+AS\s+([\w]+)/i);
-          if (aliasMatch) {
-            return aliasMatch[1].trim();
-          }
-          // Otherwise, if a dot is present, take the part after the last dot
-          if (col.includes(".")) {
-            return col.split(".").pop().trim();
-          }
-          return col;
-        });
-
-      // Ensure that essential keys are always picked
-      const requiredKeys = ["_permissions", "_permissions_", "id"];
-      const finalKeys = [...new Set([...columnList, ...requiredKeys])];
-
-      return data.map((entry) => _.pick(entry, finalKeys));
-    }
-    return data;
-  }
-
-  extractNestings(string, localType) {
-    let returnVal = [];
-
-    // Extract loop variables from ANY/EVERY expressions
-    // Loop variables (e.g., "vote" in "EVERY vote IN committee_votes") should be excluded
-    // But the collection being iterated (e.g., "committee_votes") should be INCLUDED
-    // if it's a joinable mapped property - buildJoinMetadata will filter non-joinables
-    let anyEveryRegex = /(ANY|EVERY)\s+(\w+)\s+IN\s+`?(\w+)`?/gi;
-    let anyEveryMatch;
-    const loopVariables = new Set();
-    const anyEveryCollections = new Set();
-
-    while ((anyEveryMatch = anyEveryRegex.exec(string)) !== null) {
-      loopVariables.add(anyEveryMatch[2]); // e.g., "vote" - exclude from nestings
-      anyEveryCollections.add(anyEveryMatch[3]); // e.g., "committee_votes" - include in nestings
-    }
-
-    // Now extract dot notation patterns, but skip loop variables
-    let regex = /(`?\w+`?)\.(`?\w+`?)/g;
-    let match;
-
-    while ((match = regex.exec(string)) !== null) {
-      let first = match[1].replace(/`/g, "");
-      // Skip if it's the local type or a loop variable from ANY/EVERY
-      if (first !== localType && !loopVariables.has(first)) {
-        returnVal.push(first);
-      }
-    }
-
-    // Add collections from ANY/EVERY expressions as potential nestings
-    // buildJoinMetadata will filter out non-joinable ones (embedded arrays vs mapped collections)
-    for (const collection of anyEveryCollections) {
-      if (collection !== localType) {
-        returnVal.push(collection);
-      }
-    }
-
-    return [...new Set(returnVal)];
-  }
-
-  createJoinSection(mappedNestings) {
-    if (!mappedNestings || mappedNestings.length === 0) return "";
-
-    return mappedNestings
-      .map(({ alias, reference, is_array }) => {
-        const keyspace = fixCollection(reference);
-        if (is_array === true) {
-          return `LEFT NEST \`${keyspace}\` AS \`${alias}\` ON KEYS \`${this.type}\`.\`${alias}\``;
-        } else {
-          return `LEFT JOIN \`${keyspace}\` AS \`${alias}\` ON KEYS \`${this.type}\`.\`${alias}\``;
-        }
-      })
-      .join(" ");
-  }
-
-  formatSortComponent(sortComponent) {
-    const parts = sortComponent.split(" ");
-    parts[0] = `\`${parts[0]}\``;
-    return parts.join(" ");
-  }
-
-  /**
-   * Builds join metadata from nestings for SQL joins and prepares columns.
-   * @param {string[]} nestings - Array of alias names extracted from query/columns/sort
-   * @param {Object} args - Arguments object containing columns (will be mutated with prepared columns)
-   * @returns {Object} - { mappedNestings, protectedAliases, arrayAliases }
-   */
-  buildJoinMetadata(nestings, args) {
-    // Normalize any double backticks to single backticks early (handles URL encoding issues)
-    if (args.columns && typeof args.columns === "string") {
-      args.columns = args.columns.replace(/``/g, "`");
-    }
-
-    // Decide which aliases we can join: only when map.type===MODEL AND reference is a STRING keyspace.
-    const mappedNestings = _.compact(
-      _.uniq(nestings).map((alias) => {
-        const prop = this.props[alias];
-        if (!prop?.map || prop.map.type !== MapType.MODEL) return null;
-
-        const ref = prop.map.reference;
-        if (typeof ref !== "string") {
-          // reference is a class/function/array-of-classes → no SQL join; serializer will handle it
-          return null;
-        }
-
-        const is_array =
-          prop.type === "array" ||
-          prop.type === Array ||
-          prop.type === DataType.ARRAY;
-
-        return {
-          alias,
-          reference: ref.toLowerCase(), // keyspace to join
-          is_array,
-          type: prop.type,
-          value_field: prop.map.value_field,
-          destination: prop.map.destination || alias,
-        };
-      }),
-    );
-
-    const protectedAliases = mappedNestings.map((m) => m.alias);
-    const arrayAliases = mappedNestings
-      .filter((m) => m.is_array)
-      .map((m) => m.alias);
-
-    // Columns: first prepare (prefix base table, rewrite array alias.field → ARRAY proj),
-    // then normalize names and add default aliases
-    //console.log("Columns in BuildJoinMetadata", args.columns);
-
-    this[_columns] = args.columns ?? "";
-
-    args.columns = this.prepColumns(
-      args.columns,
-      protectedAliases,
-      arrayAliases,
-    );
-
-    args.columns = this.fixColumnName(args.columns, protectedAliases);
-    //console.log("Columns in BuildJoinMetadata after fixColumnName", args.columns);
-    return { mappedNestings, protectedAliases, arrayAliases };
-  }
-
-  /* removeSpaceAndSpecialCharacters(str) {
-    return str.replace(/[^a-zA-Z0-9]/g, "");
-  } */
-
-  fixColumnName(columns, protectedAliases = []) {
-    if (!columns || typeof columns !== "string") return columns;
-    const protectedSet = new Set(protectedAliases);
-
-    const tokens = columns.split(",").map((s) => s.trim());
-    const aliasTracker = {};
-
-    const out = tokens.map((col) => {
-      if (!col) return undefined;
-
-      // Do not rewrite ARRAY projections
-      if (/^\s*ARRAY\s+/i.test(col)) return col;
-
-      // If token is literally this.type.alias → compress to `alias`
-      for (const a of protectedSet) {
-        const re = new RegExp(
-          "^`?" +
-            _.escapeRegExp(this.type) +
-            "`?\\.`?" +
-            _.escapeRegExp(a) +
-            "`?$",
-        );
-        if (re.test(col)) {
-          return `\`${a}\``;
-        }
-      }
-
-      // Extract explicit AS
-      const aliasRegex = /\s+AS\s+`?([\w]+)`?$/i;
-      const aliasMatch = col.match(aliasRegex);
-      const explicitAlias = aliasMatch ? aliasMatch[1] : null;
-      const colWithoutAlias =
-        explicitAlias ? col.replace(aliasRegex, "").trim() : col;
-
-      // `table`.`col` or table.col
-      const columnRegex = /^`?([\w]+)`?\.`?([\w]+)`?$/;
-      const match = colWithoutAlias.match(columnRegex);
-
-      let tableName = this.type;
-      let columnName = colWithoutAlias.replace(/`/g, "");
-      if (match) {
-        tableName = match[1];
-        columnName = match[2];
-      }
-
-      // For joined table columns, add default alias <table_col> if none
-      if (tableName && tableName !== this.type) {
-        let newAlias = explicitAlias || `${tableName}`;
-        if (!explicitAlias) {
-          if (aliasTracker.hasOwnProperty(newAlias)) {
-            aliasTracker[newAlias]++;
-            newAlias = `${newAlias}`;
-          } else {
-            aliasTracker[newAlias] = 0;
-          }
-          return `${colWithoutAlias} AS \`${newAlias}\``;
-        }
-      }
-
-      // If column is already qualified with base table (e.g., `user`.`field`), return as-is
-      if (tableName === this.type && match) {
-        return col;
-      }
-
-      // If column is already backtick-quoted, return as-is
-      if (col.startsWith("`") && col.endsWith("`")) {
-        return col;
-      }
-      return `\`${col}\``;
-    });
-
-    return _.join(_.compact(out), ", ");
-  }
-
-  async list(args = {}) {
-    // Profiling: use track() for proper async context forking
-    const p = this[_ctx]?.profiler;
-
-    const doList = async () => {
-      if (args.mapping_dept) this[_mapping_dept] = args.mapping_dept;
-      if (args.mapping_dept_exempt)
-        this[_mapping_dept_exempt] = args.mapping_dept_exempt;
-
-      // Find alias tokens from query/columns/sort
-      const nestings = [
-        ...this.extractNestings(args?.query || "", this.type),
-        //...this.extractNestings(args?.columns || "", this.type),
-        ...this.extractNestings(args?.sort || "", this.type),
-      ];
-
-      // Build join metadata and prepare columns
-      const { mappedNestings } = this.buildJoinMetadata(nestings, args);
-
-      // Build JOIN/NEST from the mapped keyspaces
-      args._join = this.createJoinSection(mappedNestings);
-
-      // WHERE
-      let query = "";
-      const deletedCondition = `(\`${this.type}\`.deleted = false OR \`${this.type}\`.deleted IS MISSING)`;
-      if (args.is_full_text === "true" || args.is_custom_query === "true") {
-        query = args.query || "";
-      } else if (args.filters) {
-        query = this.makeQueryFromFilter(args.filters);
-      } else if (args.query) {
-        query = `${args.query} AND ${deletedCondition}`;
-      } else {
-        query = deletedCondition;
-      }
-
-      if (hasSQLInjection(query)) return [];
-
-      // LIMIT/OFFSET/SORT
-      args.limit = Number(args.limit) || undefined;
-      args.offset = Number(args.offset) || 0;
-      args.sort =
-        args.sort ?
-          args.sort
-            .split(",")
-            .map((item) =>
-              item.includes(".") ? item : (
-                `\`${this.type}\`.${this.formatSortComponent(item)}`
-              ),
-            )
-            .join(",")
-        : `\`${this.type}\`.created_at DESC`;
-
-      if (args.skip_hooks !== true) {
-        await this.run_hook(this, "list", "before");
-      }
-
-      const cacheKey = `list::${this.type}::${args._join}::${query}::${args.limit}::${args.offset}::${args.sort}::${args.do_count}::${args.statement_consistent}::${args.columns}::${args.is_full_text}::${args.is_custom_query}`;
-      let results;
-
-      if (this.shouldUseCache(this.type)) {
-        const cached = await this.getCacheProviderObject(this.type).get(
-          cacheKey,
-        );
-        results = cached?.value;
-        const isEmpty = cached?.value === undefined;
-        const refresh = await this.shouldForceRefresh(cached);
-        if (isEmpty || refresh) {
-          results = await this.fetchResults(args, query);
-          this.getCacheProviderObject(this.type).set(
-            cacheKey,
-            { value: results, time: new Date().getTime() },
-            this.getCacheConfig(this.type),
-          );
-        }
-      } else {
-        results = await this.fetchResults(args, query);
-      }
-
-      // Serializer still handles class-based refs and value_field
-      if (args.skip_read_serialize !== true && args.skip_serialize !== true) {
-        results.data = await this.do_serialize(
-          results.data,
-          "read",
-          {},
-          args,
-          await this.propsToBeRemoved(results.data),
-        );
-      }
-
-      if (args.skip_hooks !== true) {
-        await this.run_hook(results.data, "list", "after");
-      }
-
-      results.data = this.filterResultsByColumns(results.data, args.columns);
-      //console.log("results.data", results.data);
-      return results;
-    };
-
-    try {
-      if (p) {
-        return await p.track(`${this.type}.list`, doList, {
-          limit: args?.limit,
-          offset: args?.offset,
-        });
-      }
-      return await doList();
-    } catch (e) {
-      console.warn(e.stack);
-      throw e;
-    }
-  }
-
-  async fetchResults(args, query) {
-    // Profiling: use track() for proper async context forking
-    const p = this[_ctx]?.profiler;
-
-    const doFetch = async () => {
-      if (args.is_custom_query === "true" && args.ids.length > 0) {
-        return await this.database.query(query);
-      } else if (args.is_full_text === "true") {
-        return await this.database.full_text_search(
-          this.type,
-          query || "",
-          args.limit,
-          args.offset,
-          args._join,
-        );
-      } else {
-        let result = await this.database.search(
-          this.type,
-          args.columns || "",
-          query || "",
-          args.limit,
-          args.offset,
-          args.sort,
-          args.do_count,
-          args.statement_consistent,
-          args._join,
-        );
-        return result;
-      }
-    };
-
-    if (p) {
-      return await p.track(`${this.type}.fetchResults`, doFetch);
-    }
-    return await doFetch();
-  }
-
-  addHook({ operation, when, execute }) {
-    this[_hooks][operation][when].push(execute);
-  }
-
-  async run_hook(data, op, when, old_data) {
-    try {
-      if (this[_disable_lifecycle_events] == false) {
-        let resourceLifecycleTriggered = new ResourceLifecycleTriggered({
-          data: {
-            data,
-            operation: op,
-            when,
-            old_data,
-            resource: this.type,
-            ctx: this[_ctx],
-          },
-        });
-        resourceLifecycleTriggered.dispatch();
-      }
-      if (this[_hooks] && this[_hooks][op] && this[_hooks][op][when]) {
-        for (let i of this[_hooks][op][when]) {
-          data = await i(data, old_data);
-        }
-      }
-      return data;
-    } catch (e) {
-      throw e;
-    }
-  }
-
-  shouldSerializerRun(args, type) {
-    if (args) {
-      if (args.skip_serialize == true) {
-        return false;
-      }
-      if (type == "read") {
-        if (args.skip_read_serialize == true) {
-          return false;
-        }
-      } else if (type == "write") {
-        if (args.skip_write_serialize == true) {
-          return false;
-        }
-      }
-    }
-    return true;
-  }
-
-  // Check if a field is exempt from mapping depth limits
-  // Supports deep references like "group.permissions"
-  isFieldExempt(source_property) {
-    const currentPath = this[_current_path];
-    const fullPath =
-      currentPath ? `${currentPath}.${source_property}` : source_property;
-
-    return this[_mapping_dept_exempt].some((exemptPattern) => {
-      // Exact match: "group" or "group.permissions"
-      if (exemptPattern === source_property || exemptPattern === fullPath) {
-        return true;
-      }
-      // Pattern starts with current full path (e.g., "group.permissions" starts with "group")
-      if (exemptPattern.startsWith(fullPath + ".")) {
-        return true;
-      }
-      // Full path starts with pattern (e.g., we're at "group.permissions" and "group" is exempt)
-      if (fullPath.startsWith(exemptPattern + ".")) {
-        return true;
-      }
-      return false;
-    });
-  }
-
-  async mapToObject(
-    data,
-    Class,
-    source_property,
-    store_property,
-    property,
-    args,
-    type,
-    mapping_dept,
-    level,
-    columns,
-  ) {
-    // ⚡ Get profiler for proper async context forking
-    const p = this[_ctx]?.profiler;
-    // create a array of all columns in args.columns skipping the first_segment of the Column string and pull out all the columns of where the new first segment matches source_property
-    // Create a set of columns where the first segment matches source_property
-    let columnArray = [];
-    if (columns) {
-      columns.split(",").forEach((col) => {
-        const parts = col.trim().split("."); // remove the first segment
-        // Also match if parts[0] is source_property or '`' + source_property + '`'
-        const firstPart = parts[0];
-        // Remove backticks if present
-        const cleanFirstPart =
-          firstPart && firstPart.startsWith("`") && firstPart.endsWith("`") ?
-            firstPart.slice(1, -1)
-          : firstPart;
-
-        if (
-          parts.length > 0 &&
-          (firstPart === source_property || cleanFirstPart === source_property)
-        ) {
-          // Use cleanFirstPart for the map key to handle both cases consistently
-          // Remove backticks from each column segment, if present, before joining
-          columnArray.push(
-            parts
-              .slice(1)
-              .map((segment) =>
-                segment && segment.startsWith("`") && segment.endsWith("`") ?
-                  segment.slice(1, -1)
-                : segment,
-              )
-              .join("."),
-          );
-        }
-      });
-    }
-    let original_is_array = _.isArray(data);
-    if (!original_is_array) {
-      data = Array.of(data);
-    }
-    const isExempt = this.isFieldExempt(source_property);
-    if (isExempt || this[_level] + 1 < this[_mapping_dept]) {
-      let classes = _.compact(_.isArray(Class) ? Class : [Class]);
-
-      let ids = [];
-      _.each(data, (result) => {
-        let value = result[source_property];
-
-        // Check if value is in the empty string key (column aliasing issue)
-        if (
-          (value === undefined || (_.isObject(value) && _.isEmpty(value))) &&
-          result[""] &&
-          result[""][source_property]
-        ) {
-          value = result[""][source_property];
-        }
-
-        if (_.isString(value) && value !== "") {
-          // PATCH: Use strict inequality
-          // Value is a raw ID string
-          ids = _.union(ids, [value]);
-        } else if (
-          _.isObject(value) &&
-          _.isString(value.id) &&
-          value.id !== ""
-        ) {
-          // PATCH: Use strict inequality
-          // Value is already a joined object with an id field
-          ids = _.union(ids, [value.id]);
-        }
-      });
-
-      // PATCH: Remove empty strings, nulls, and deduplicate IDs
-      ids = _.compact(_.uniq(ids));
-
-      // PATCH: Early exit if no valid IDs
-      if (ids.length === 0) {
-        return original_is_array ? data : data[0];
-      }
-
-      // Build the path for child models
-      const childPath =
-        this[_current_path] ?
-          `${this[_current_path]}.${source_property}`
-        : source_property;
-
-      // ⚡ Wrap in profiler track() to ensure proper async context for child operations
-      const fetchRelated = async () => {
-        return await Promise.allSettled(
-          _.map(classes, (obj) => {
-            let objInstance = new obj({
-              ...this[_args],
-              skip_cache: this[_skip_cache],
-              _level: this[_level] + 1,
-              mapping_dept: this[_mapping_dept],
-              mapping_dept_exempt: this[_mapping_dept_exempt],
-              _columns: columnArray.join(","),
-              _current_path: childPath,
-            });
-
-            return objInstance.getMulti({
-              skip_hooks: true,
-              ids: ids,
-              columns: columnArray,
-            });
-          }),
-        );
-      };
-
-      var returned_all;
-      if (p && ids.length > 0) {
-        returned_all = await p.track(
-          `${this.type}.map.${source_property}`,
-          fetchRelated,
-          { ids_count: ids.length },
-        );
-      } else {
-        returned_all = await fetchRelated();
-      }
-
-      let ug = _.flatten(
-        _.compact(
-          _.map(returned_all, (returned_obj) => {
-            if (returned_obj.status == "fulfilled") {
-              return returned_obj.value;
-            }
-          }),
-        ),
-      );
-
-      /* if(source_property == "group") {
-        console.log("Returned All", source_property, store_property, ug);
-      } */
-
-      data = _.map(data, (result) => {
-        let sourceValue = result[source_property];
-
-        // Check if value is in the empty string key (column aliasing issue)
-        if (
-          (sourceValue === undefined ||
-            (_.isObject(sourceValue) && _.isEmpty(sourceValue))) &&
-          result[""] &&
-          result[""][source_property]
-        ) {
-          sourceValue = result[""][source_property];
-        }
-
-        // Get the ID to match against - either a string ID or the id property of an object
-        const sourceId =
-          _.isString(sourceValue) ? sourceValue
-          : _.isObject(sourceValue) ? sourceValue.id
-          : null;
-        // PATCH: Use strict equality to prevent type coercion issues
-        let result_found =
-          _.find(ug, (g) => {
-            return g.id === sourceId && sourceId !== null && sourceId !== "";
-          }) || {};
-        result[store_property] = result_found;
-        return result;
-      });
-    }
-    return original_is_array ? data : data[0];
-  }
-
-  async mapToObjectArray(
-    data,
-    Class,
-    source_property,
-    store_property,
-    property,
-    args,
-    type,
-    mapping_dept,
-    level,
-    columns,
-  ) {
-    // ⚡ Get profiler for proper async context forking
-    const p = this[_ctx]?.profiler;
-
-    let columnArray = [];
-    if (columns) {
-      columns.split(",").forEach((col) => {
-        const parts = col.trim().split("."); // remove the first segment
-        // Also match if parts[0] is source_property or '`' + source_property + '`'
-        const firstPart = parts[0];
-        // Remove backticks if present
-        const cleanFirstPart =
-          firstPart && firstPart.startsWith("`") && firstPart.endsWith("`") ?
-            firstPart.slice(1, -1)
-          : firstPart;
-
-        if (
-          parts.length > 0 &&
-          (firstPart === source_property || cleanFirstPart === source_property)
-        ) {
-          // Use cleanFirstPart for the map key to handle both cases consistently
-          // Remove backticks from each column segment, if present, before joining
-          columnArray.push(
-            parts
-              .slice(1)
-              .map((segment) =>
-                segment && segment.startsWith("`") && segment.endsWith("`") ?
-                  segment.slice(1, -1)
-                : segment,
-              )
-              .join("."),
-          );
-        }
-      });
-    }
-
-    let original_is_array = _.isArray(data);
-    if (!original_is_array) {
-      data = Array.of(data);
-    }
-    const isExempt = this.isFieldExempt(source_property);
-    if (isExempt || this[_level] + 1 < this[_mapping_dept]) {
-      let ids = [];
-      _.each(data, (result) => {
-        let value = [];
-
-        if (_.isArray(result[source_property])) {
-          value = result[source_property];
-        }
-
-        if (_.isString(result[source_property])) {
-          value = [result[source_property]];
-        }
-
-        // Extract IDs - handle both string IDs and objects with id property
-        let items = _.compact(
-          _.map(value, (obj) => {
-            if (_.isString(obj) && obj !== "") {
-              // PATCH: Use strict inequality
-              return obj;
-            } else if (_.isObject(obj) && _.isString(obj.id) && obj.id !== "") {
-              // PATCH: Use strict inequality
-              return obj.id;
-            }
-            return null;
-          }),
-        );
-        ids = _.union(ids, items);
-      });
-
-      // PATCH: Deduplicate IDs to prevent redundant queries
-      ids = _.uniq(ids);
-
-      // PATCH: Early exit if no valid items
-      if (ids.length === 0) {
-        return original_is_array ? data : data[0];
-      }
-
-      // Build the path for child models
-      const childPath =
-        this[_current_path] ?
-          `${this[_current_path]}.${source_property}`
-        : source_property;
-
-      let classes = _.compact(_.isArray(Class) ? Class : [Class]);
-
-      // ⚡ Wrap in profiler track() to ensure proper async context for child operations
-      const fetchRelated = async () => {
-        return await Promise.allSettled(
-          _.map(classes, (obj) => {
-            return new obj({
-              ...this[_args],
-              skip_cache: this[_skip_cache],
-              _level: this[_level] + 1,
-              mapping_dept: this[_mapping_dept],
-              mapping_dept_exempt: this[_mapping_dept_exempt],
-              _columns: columnArray.join(","),
-              _current_path: childPath,
-            }).getMulti({
-              skip_hooks: true,
-              ids: ids,
-              columns: columnArray,
-            });
-          }),
-        );
-      };
-
-      var returned_all;
-      if (p && ids.length > 0) {
-        returned_all = await p.track(
-          `${this.type}.mapArray.${source_property}`,
-          fetchRelated,
-          { ids_count: ids.length },
-        );
-      } else {
-        returned_all = await fetchRelated();
-      }
-
-      var returned_objects = _.flatten(
-        _.compact(
-          _.map(returned_all, (returned_obj) => {
-            if (returned_obj.status == "fulfilled") return returned_obj.value;
-          }),
-        ),
-      );
-
-      _.each(data, (result) => {
-        if (_.isString(result[store_property])) {
-          result[store_property] = [result[store_property]];
-        }
-
-        if (!_.has(result, source_property)) {
-          result[source_property] = [];
-          return;
-        }
-
-        result[store_property] = _.map(result[source_property], (item) => {
-          // Get the ID to match - either a string ID or the id property of an object
-          const itemId =
-            _.isString(item) ? item
-            : _.isObject(item) ? item.id
-            : null;
-          return _.find(returned_objects, (p) => p.id === itemId);
-        });
-        result[store_property] = _.reject(
-          result[store_property],
-          (obj) => obj === null || obj === undefined,
-        );
-      });
-    }
-    return original_is_array ? data : data[0];
-  }
-
-  addModifier({ when, execute }) {
-    if (this[_serializers][when]) {
-      this[_serializers][when]["modifiers"].push(execute);
-    }
-  }
-
-  createModifiersFromProps() {
-    this.createMofifier(this.props);
-    this.addExternalModifiers();
-  }
-
-  addExternalModifiers(scope = "*") {
-    let that = this;
-    _.each([...spice.getModifiers(scope)], function (modifier) {
-      that.addModifier(modifier);
-    });
-  }
-
-  /**
-   * Extracts the first segment of each column path for database queries.
-   * e.g., ["name", "permissions.permission"] → ["name", "permissions"]
-   * @param {string[]} columns - Array of column paths
-   * @returns {string[]} - Array of base column names (deduplicated)
-   */
-  extractBaseColumns(columns) {
-    if (!columns || !Array.isArray(columns)) return columns;
-    return [
-      ...new Set(
-        columns.map((col) => {
-          const firstDot = col.indexOf(".");
-          return firstDot > -1 ? col.substring(0, firstDot) : col;
-        }),
-      ),
-    ];
-  }
-
-  /**
-   * Checks if a field is present in the columns string.
-   * Used to skip modifier execution when the field isn't requested.
-   * @param {string} fieldName - The field name to check for
-   * @param {string} columns - Comma-separated column string
-   * @returns {boolean} - True if field is in columns or columns is empty (fetch all)
-   */
-  isFieldInColumns(fieldName, columns) {
-    // No columns filter = include all
-    if (!columns || columns === "") return true;
-
-    const tokens = columns.split(",");
-    for (const col of tokens) {
-      const trimmed = col.trim();
-      // Check if this column starts with the field name (exact match or nested like "fieldName.subfield")
-      const firstPart = trimmed.split(".")[0];
-      // Handle backtick-wrapped column names
-      const cleanFirstPart =
-        firstPart.startsWith("`") && firstPart.endsWith("`") ?
-          firstPart.slice(1, -1)
-        : firstPart;
-
-      if (cleanFirstPart === fieldName) {
-        return true;
-      }
-    }
-    return false;
-  }
-
-  createMofifier(properties) {
-    for (let i in properties) {
-      if (properties[i].map) {
-        switch (properties[i].map.type) {
-          case MapType.MODEL: {
-            switch (properties[i].type) {
-              case String:
-              case "string": {
-                this.addModifier({
-                  when: properties[i].map.when || "read",
-                  execute: async (
-                    data,
-                    old_data,
-                    ctx,
-                    type,
-                    args,
-                    mapping_dept,
-                    level,
-                    columns,
-                  ) => {
-                    // Skip if columns are specified but this field isn't included
-                    if (!this.isFieldInColumns(i, columns)) {
-                      return data;
-                    }
-                    return await this.mapToObject(
-                      data,
-                      _.isString(properties[i].map.reference) ?
-                        spice.models[properties[i].map.reference]
-                      : properties[i].map.reference,
-                      i,
-                      properties[i].map.destination || i,
-                      properties[i],
-                      args,
-                      type,
-                      mapping_dept,
-                      level,
-                      columns,
-                    );
-                  },
-                });
-                break;
-              }
-              case Array:
-              case "array": {
-                this.addModifier({
-                  when: properties[i].map.when || "read",
-                  execute: async (
-                    data,
-                    old_data,
-                    ctx,
-                    type,
-                    args,
-                    mapping_dept,
-                    level,
-                    columns,
-                  ) => {
-                    // Skip if columns are specified but this field isn't included
-                    if (!this.isFieldInColumns(i, columns)) {
-                      return data;
-                    }
-                    return await this.mapToObjectArray(
-                      data,
-                      _.isString(properties[i].map.reference) ?
-                        spice.models[properties[i].map.reference]
-                      : properties[i].map.reference,
-                      i,
-                      properties[i].map.destination || i,
-                      properties[i],
-                      args,
-                      type,
-                      mapping_dept,
-                      level,
-                      columns,
-                    );
-                  },
-                });
-                break;
-              }
-            }
-            break;
-          }
-          case MapType.LOOKUP: {
-            break;
-          }
-        }
-      }
-    }
-  }
-
-  async do_serialize(data, type, old_data, args, path_to_be_removed = []) {
-    // Profiling: use track() for proper async context forking
-    const p = this[_ctx]?.profiler;
-
-    const doSerialize = async () => {
-      // Early exit if serialization should not run.
-      if (!this.shouldSerializerRun(args, type)) {
-        return data;
-      }
-
-      // Add external modifiers only once.
-      if (this.type && !this[_external_modifier_loaded]) {
-        this.addExternalModifiers(this.type);
-        this[_external_modifier_loaded] = true;
-      }
-
-      // Cache the modifiers lookup for the specified type.
-      const modifiers = this[_serializers]?.[type]?.modifiers || [];
-      for (let i = 0; i < modifiers.length; i++) {
-        const modifier = modifiers[i];
-        try {
-          const result = await modifier(
-            data,
-            old_data,
-            this[_ctx],
-            this.type,
-            args,
-            this[_mapping_dept],
-            this[_level],
-            this[_columns],
-          );
-          // Guard against modifiers that return undefined
-          if (result !== undefined) {
-            data = result;
-          } else {
-            console.warn(
-              `Modifier #${i} for type=${this.type} returned undefined, keeping previous data`,
-            );
-          }
-        } catch (error) {
-          console.error(
-            `Modifier error in do_serialize (type=${this.type}, modifier #${i}):`,
-            error instanceof Error ?
-              error.stack
-            : `Non-Error thrown: ${JSON.stringify(error)}`,
-          );
-        }
-      }
-
-      // Ensure data is always an array for consistent processing.
-      const originalIsArray = Array.isArray(data);
-      if (!originalIsArray) {
-        data = [data];
-      }
-
-      // Compute the defaults from properties using reduce.
-      const defaults = Object.keys(this.props).reduce((acc, key) => {
-        const def = this.props[key]?.defaults?.[type];
-        if (def !== undefined) {
-          acc[key] =
-            _.isFunction(def) ?
-              def({ old_data: data, new_data: old_data })
-            : def;
-        }
-        return acc;
-      }, {});
-
-      // Merge defaults into each object.
-      data = data.map((item) => _.defaults(item, defaults));
-
-      // If type is "read", clean the data by omitting certain props.
-      if (type === "read") {
-        // Collect hidden properties from schema.
-        const hiddenProps = Object.keys(this.props).filter(
-          (key) => this.props[key]?.hide,
-        );
-        // Combine default props to remove.
-        const propsToClean = [
-          "deleted",
-          "type",
-          "collection",
-          ...path_to_be_removed,
-          ...hiddenProps,
-        ];
-        data = data.map((item) => _.omit(item, propsToClean));
-      }
-
-      // Return in the original format (array or single object).
-      return originalIsArray ? data : data[0];
-    };
-
-    try {
-      if (p) {
-        return await p.track(`${this.type}.do_serialize`, doSerialize, {
-          type,
-        });
-      }
-      return await doSerialize();
-    } catch (error) {
-      console.error(
-        "Error in do_serialize:",
-        error instanceof Error ?
-          error.stack
-        : `Non-Error thrown: ${JSON.stringify(error)}`,
-      );
-      throw error;
-    }
-  }
-}