@nhtio/lucid-resourceful 0.1.0-master-71781cfd → 0.1.0-master-3ec631a4

package/index.cjs

@@ -10,19 +10,16 @@ var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read fr
 var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
 var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
 var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
-var _a, _hookHandlers, _cleanupHandlers, _state, _handlersToIgnore, _skipAllHooks, _Runner_instances, filter_fn, exec_fn, _b, _hooks, _c, _d;
+var _attributesToColumns, _allowedColumns, _connection, _dialect, _primaryKey, _tableName, _model, _LuceneLucidQueryBuilder_instances, getSearchableColumns_fn, _OpenApiSchemaService_instances, getFieldKey_fn, extractDataTypeInfo_fn, _a, _hookHandlers, _cleanupHandlers, _state, _handlersToIgnore, _skipAllHooks, _Runner_instances, filter_fn, exec_fn, _b, _hooks, _c, _d;
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const decorator_utils = require("./decorator_utils-U_rZo8tv.cjs");
+const decorator_utils = require("./decorator_utils-DSvYjLYD.cjs");
 const joi = require("./joi.cjs");
 const liqe = require("liqe");
-const errors = require("./errors-D8jb9VxY.cjs");
-const definitions = require("./definitions-DgI468dW.cjs");
+const errors = require("./errors-CNwuNhBV.cjs");
 const require$$0 = require("util");
 require("node:path");
 require("node:url");
-const stripUndefinedValuesFromObject = (obj) => {
-  return Object.fromEntries(Object.entries(obj).filter(([_, value]) => value !== void 0));
-};
+const definitions = require("./definitions-DjQRkCeH.cjs");
 async function pMap(iterable, mapper, {
   concurrency = Number.POSITIVE_INFINITY,
   stopOnError = true,
@@ -144,384 +141,426 @@ async function pMap(iterable, mapper, {
   });
 }
 const pMapSkip = Symbol("skip");
-const applyLuceneLogicalExpressionAst = (ast, query, attributesToColumns, primaryKey, tableName, allowedColumns) => {
-  const operatorType = ast.operator.operator;
-  query.where((subQuery) => {
-    if (operatorType === "AND") {
-      applyLuceneAst(ast.left, subQuery, attributesToColumns, primaryKey, tableName, allowedColumns);
-      applyLuceneAst(
-        ast.right,
-        subQuery,
-        attributesToColumns,
-        primaryKey,
-        tableName,
-        allowedColumns
-      );
-    } else {
-      subQuery.orWhere((orSubQuery) => {
-        applyLuceneAst(
-          ast.left,
-          orSubQuery,
-          attributesToColumns,
-          primaryKey,
-          tableName,
-          allowedColumns
-        );
+const _LuceneLucidQueryBuilder = class _LuceneLucidQueryBuilder {
+  constructor(connection, query, attributesToColumns, primaryKey, tableName, allowedColumns, model) {
+    __privateAdd(this, _LuceneLucidQueryBuilder_instances);
+    __privateAdd(this, _attributesToColumns);
+    __privateAdd(this, _allowedColumns);
+    __privateAdd(this, _connection);
+    __privateAdd(this, _dialect);
+    // @ts-ignore - not used yet
+    __privateAdd(this, _primaryKey);
+    // @ts-ignore - not used yet
+    __privateAdd(this, _tableName);
+    // @ts-ignore - not used yet
+    __privateAdd(this, _model);
+    __privateSet(this, _attributesToColumns, attributesToColumns);
+    __privateSet(this, _primaryKey, primaryKey);
+    __privateSet(this, _tableName, tableName);
+    __privateSet(this, _allowedColumns, allowedColumns);
+    __privateSet(this, _model, model);
+    __privateSet(this, _connection, connection);
+    __privateSet(this, _dialect, query.client.dialect.name);
+  }
+  applyLuceneAst(ast, query, throwOnInvalidType = false) {
+    switch (ast.type) {
+      case "EmptyExpression":
+        this.applyLuceneEmptyExpressionAst(ast, query);
+        break;
+      case "LogicalExpression":
+        this.applyLuceneLogicalExpressionAst(ast, query);
+        break;
+      case "ParenthesizedExpression":
+        this.applyLuceneParenthesizedExpressionAst(ast, query);
+        break;
+      case "UnaryOperator":
+        this.applyLuceneUnaryOperatorAst(ast, query);
+        break;
+      case "Tag":
+        this.applyLuceneTagAst(ast, query);
+        break;
+      default:
+        if (throwOnInvalidType) {
+          throw new errors.E_LUCENE_INVALID_TYPE(ast.type);
+        }
+        break;
+    }
+  }
+  applyLuceneEmptyExpressionAst(_ast, _query) {
+  }
+  applyLuceneLogicalExpressionAst(ast, query) {
+    const operatorType = ast.operator.operator;
+    query.where((subQuery) => {
+      if (operatorType === "AND") {
+        this.applyLuceneAst(ast.left, subQuery);
+        this.applyLuceneAst(ast.right, subQuery);
+      } else {
+        subQuery.orWhere((orSubQuery) => {
+          this.applyLuceneAst(ast.left, orSubQuery);
+        });
+        subQuery.orWhere((orSubQuery) => {
+          this.applyLuceneAst(ast.right, orSubQuery);
+        });
+      }
+    });
+  }
+  applyLuceneParenthesizedExpressionAst(ast, query) {
+    query.where((subQuery) => {
+      this.applyLuceneAst(ast.expression, subQuery);
+    });
+  }
+  applyLuceneUnaryOperatorAst(ast, query) {
+    const operator = ast.operator;
+    if (operator === "NOT" || operator === "-") {
+      query.whereNot((subQuery) => {
+        this.applyLuceneAst(ast.operand, subQuery);
       });
-      subQuery.orWhere((orSubQuery) => {
-        applyLuceneAst(
-          ast.right,
-          orSubQuery,
-          attributesToColumns,
-          primaryKey,
-          tableName,
-          allowedColumns
-        );
+    } else {
+      query.where((subQuery) => {
+        this.applyLuceneAst(ast.operand, subQuery);
       });
     }
-  });
-};
-const applyLuceneParenthesizedExpressionAst = (ast, query, attributesToColumns, primaryKey, tableName, allowedColumns) => {
-  query.where((subQuery) => {
-    applyLuceneAst(
-      ast.expression,
-      subQuery,
-      attributesToColumns,
-      primaryKey,
-      tableName,
-      allowedColumns
-    );
-  });
-};
-const applyLuceneEmptyExpression = (column2, _expression, operator, query, _attributesToColumns, _primaryKey, _tableName, _allowedColumns) => {
-  switch (operator.operator) {
-    case ":":
-    case ":=":
-    case ":<=":
-    case ":>=":
-      query.where((sub) => {
-        sub.whereNull(column2);
-        sub.orWhere(column2, "=", "");
+  }
+  applyLuceneTagAst(ast, query) {
+    const { expression, field, operator } = ast;
+    switch (field.type) {
+      case "ImplicitField":
+        this.applyLuceneImplicitFieldAst(field, expression, operator, query);
+        break;
+      case "Field":
+        this.applyLuceneFieldAst(field, expression, operator, query);
+        break;
+    }
+  }
+  applyLuceneImplicitFieldAst(_field, expression, operator, query) {
+    const searchableColumns = __privateMethod(this, _LuceneLucidQueryBuilder_instances, getSearchableColumns_fn).call(this);
+    const defaultOperator = operator || {
+      operator: ":",
+      type: "ComparisonOperator",
+      location: { start: 0, end: 0 }
+    };
+    searchableColumns.forEach((columnName) => {
+      const fakeField = {
+        name: columnName,
+        type: "Field",
+        location: { start: 0, end: 0 },
+        quoted: false
+      };
+      query.orWhere((s) => {
+        this.applyLuceneFieldAst(fakeField, expression, defaultOperator, s);
       });
-      break;
+    });
   }
-};
-const applyLuceneLiteralExpression = (column2, expression, operator, query, _attributesToColumns, _primaryKey, _tableName, _allowedColumns) => {
-  let value = expression.value;
-  if (value === null) {
+  applyLuceneFieldAst(field, expression, operator, query, forModel) {
+    const columnName = !forModel ? __privateGet(this, _attributesToColumns).get(field.name) : forModel.$keys.attributesToColumns.get(field.name);
+    if (!columnName || !forModel && __privateGet(this, _allowedColumns) && !__privateGet(this, _allowedColumns).includes(field.name)) {
+      if (field.name.includes(".")) {
+        const parts = field.name.split(".").filter((p) => "string" === typeof p && p.trim().length > 0).map((p) => p.trim());
+        const relationship = parts.shift();
+        if (!relationship || parts.length === 0) return;
+        this.applyLuceneRelatedFieldAst(
+          relationship,
+          parts.join("."),
+          expression,
+          operator,
+          query,
+          forModel
+        );
+      }
+      return;
+    }
+    switch (expression.type) {
+      case "EmptyExpression":
+        this.applyLuceneEmptyExpression(columnName, expression, operator, query);
+        break;
+      case "LiteralExpression":
+        this.applyLuceneLiteralExpression(columnName, expression, operator, query);
+        break;
+      case "RangeExpression":
+        this.applyLuceneRangeExpression(columnName, expression, operator, query);
+        break;
+      case "RegexExpression":
+        this.applyLuceneRegexExpression(columnName, expression, operator, query);
+        break;
+    }
+  }
+  applyLuceneRelatedFieldAst(relationship, relatedProperty, expression, operator, query, forModel) {
+    if (!forModel && !__privateGet(this, _model)) return;
+    const targetModel = forModel || __privateGet(this, _model);
+    const lucidRelationshipDefinition = targetModel.$relationsDefinitions.get(relationship);
+    if (!lucidRelationshipDefinition) return;
+    const sub = lucidRelationshipDefinition.subQuery(__privateGet(this, _connection));
+    const relatedField = {
+      name: relatedProperty,
+      type: "Field",
+      location: { start: 0, end: 0 },
+      quoted: false
+    };
+    const relatedModel = lucidRelationshipDefinition.relatedModel();
+    this.applyLuceneFieldAst(relatedField, expression, operator, sub, relatedModel);
+    query.whereExists(sub.prepare());
+  }
+  applyLuceneEmptyExpression(column2, _expression, operator, query) {
     switch (operator.operator) {
       case ":":
       case ":=":
+      case ":<=":
+      case ":>=":
         query.where((sub) => {
           sub.whereNull(column2);
           sub.orWhere(column2, "=", "");
-          sub.orWhere(column2, "=", 0);
         });
         break;
-      case ":<":
-        query.where(column2, "<", 0);
-        break;
-      case ":<=":
-        query.where(column2, "<=", 0);
-        break;
-      case ":>":
-        query.where(column2, ">", 0);
-        break;
-      case ":>=":
-        query.where(column2, ">=", 0);
-        break;
-    }
-    return;
-  }
-  if ("string" === typeof value && expression.quoted) {
-    if (expression.quotes === "double") {
-      value = value.replace(/^"/g, "").replace(/"$/g, "");
-    } else if (expression.quotes === "single") {
-      value = value.replace(/^'/g, "").replace(/'$/g, "");
     }
   }
-  switch (typeof value) {
-    case "string":
+  applyLuceneLiteralExpression(column2, expression, operator, query) {
+    let value = expression.value;
+    let isCaseSensitive = false;
+    if (value === null) {
       switch (operator.operator) {
         case ":":
         case ":=":
           query.where((sub) => {
-            sub.where(column2, "=", value);
-            sub.orWhere(column2, "like", value);
+            sub.whereNull(column2);
+            sub.orWhere(column2, "=", "");
+            sub.orWhere(column2, "=", 0);
           });
           break;
         case ":<":
-          query.where(column2, "<", value);
-          break;
-        case ":<=":
-          query.where(column2, "<=", value);
-          break;
-        case ":>":
-          query.where(column2, ">", value);
-          break;
-        case ":>=":
-          query.where(column2, ">=", value);
-          break;
-      }
-      break;
-    case "number":
-      switch (operator.operator) {
-        case ":":
-        case ":=":
-          query.where(column2, "=", value);
-          break;
-        case ":<":
-          query.where(column2, "<", value);
+          query.where(column2, "<", 0);
           break;
         case ":<=":
-          query.where(column2, "<=", value);
+          query.where(column2, "<=", 0);
           break;
         case ":>":
-          query.where(column2, ">", value);
+          query.where(column2, ">", 0);
           break;
         case ":>=":
-          query.where(column2, ">=", value);
+          query.where(column2, ">=", 0);
           break;
       }
-      break;
-    case "boolean":
-      switch (operator.operator) {
-        case ":":
-        case ":=":
-          query.where(column2, "=", value);
-          break;
-        case ":<":
-          query.where(column2, "<", value);
-          break;
-        case ":<=":
-          query.where(column2, "<=", value);
-          break;
-        case ":>":
-          query.where(column2, ">", value);
-          break;
-        case ":>=":
-          query.where(column2, ">=", value);
-          break;
+      return;
+    }
+    if ("string" === typeof value && expression.quoted) {
+      isCaseSensitive = true;
+      if (expression.quotes === "double") {
+        value = value.replace(/^"/g, "").replace(/"$/g, "");
+      } else if (expression.quotes === "single") {
+        value = value.replace(/^'/g, "").replace(/'$/g, "");
       }
-      break;
-  }
-};
-const applyLuceneRangeExpression = (column2, expression, operator, query, _attributesToColumns, _primaryKey, _tableName, _allowedColumns) => {
-  const comparableMin = expression.range.minInclusive ? expression.range.min : expression.range.min + 1;
-  const comparableMax = expression.range.maxInclusive ? expression.range.max : expression.range.max - 1;
-  switch (operator.operator) {
-    case ":":
-    case ":=":
-      query.whereBetween(column2, [comparableMin, comparableMax]);
-      break;
-  }
-};
-const applyLuceneRegexExpression = (column2, expression, operator, query, _attributesToColumns, _primaryKey, _tableName, _allowedColumns) => {
-  let value = expression.value;
-  value = value.replace(/%/g, "\\%").replace(/_/g, "\\_");
-  value = value.replace(/\*/g, "%").replace(/\?/g, "_");
-  switch (operator.operator) {
-    case ":":
-    case ":=":
-      query.whereLike(column2, value);
-      break;
-  }
-};
-const applyLuceneImplicitFieldAst = (_field, expression, operator, query, attributesToColumns, primaryKey, tableName, allowedColumns) => {
-  const columnName = primaryKey;
-  if (allowedColumns && !allowedColumns.includes(columnName)) {
-    return;
-  }
-  const defaultOperator = operator || {
-    operator: ":"
-  };
-  switch (expression.type) {
-    case "EmptyExpression":
-      applyLuceneEmptyExpression(
-        columnName,
-        expression,
-        defaultOperator,
-        query
-      );
-      break;
-    case "LiteralExpression":
-      applyLuceneLiteralExpression(
-        columnName,
-        expression,
-        defaultOperator,
-        query
-      );
-      break;
-    case "RangeExpression":
-      applyLuceneRangeExpression(
-        columnName,
-        expression,
-        defaultOperator,
-        query
-      );
-      break;
-    case "RegexExpression":
-      applyLuceneRegexExpression(
-        columnName,
-        expression,
-        defaultOperator,
-        query
-      );
-      break;
-  }
-};
-const applyLuceneFieldAst = (field, expression, operator, query, attributesToColumns, primaryKey, tableName, allowedColumns) => {
-  const columnName = attributesToColumns.get(field.name);
-  if (!columnName || allowedColumns && !allowedColumns.includes(field.name)) {
-    return;
-  }
-  switch (expression.type) {
-    case "EmptyExpression":
-      applyLuceneEmptyExpression(
-        columnName,
-        expression,
-        operator,
-        query
-      );
-      break;
-    case "LiteralExpression":
-      applyLuceneLiteralExpression(
-        columnName,
-        expression,
-        operator,
-        query
-      );
-      break;
-    case "RangeExpression":
-      applyLuceneRangeExpression(
-        columnName,
-        expression,
-        operator,
-        query
-      );
-      break;
-    case "RegexExpression":
-      applyLuceneRegexExpression(
-        columnName,
-        expression,
-        operator,
-        query
-      );
-      break;
+    }
+    switch (typeof value) {
+      case "string":
+        switch (operator.operator) {
+          case ":":
+          case ":=":
+            if (value.includes("*") || value.includes("?")) {
+              let likeValue = value.replace(/%/g, "\\%").replace(/_/g, "\\_");
+              likeValue = likeValue.replace(/\*/g, "%").replace(/\?/g, "_");
+              if (isCaseSensitive) {
+                query.whereLike(column2, likeValue);
+              } else {
+                query.if(
+                  ["postgres", "pg"].includes(__privateGet(this, _dialect)),
+                  (q) => {
+                    q.whereILike(column2, likeValue);
+                  },
+                  (q) => {
+                    q.whereLike(column2, likeValue);
+                  }
+                );
+              }
+            } else {
+              query.where((sub) => {
+                if (isCaseSensitive) {
+                  sub.where(column2, "=", value);
+                } else {
+                  query.if(
+                    ["postgres", "pg"].includes(__privateGet(this, _dialect)),
+                    () => {
+                      sub.orWhereILike(column2, value);
+                    },
+                    () => {
+                      sub.whereLike(column2, value);
+                    }
+                  );
+                }
+              });
+            }
+            break;
+          case ":<":
+            query.where(column2, "<", value);
+            break;
+          case ":<=":
+            query.where(column2, "<=", value);
+            break;
+          case ":>":
+            query.where(column2, ">", value);
+            break;
+          case ":>=":
+            query.where(column2, ">=", value);
+            break;
+        }
+        break;
+      case "number":
+        switch (operator.operator) {
+          case ":":
+          case ":=":
+            query.where(column2, "=", value);
+            break;
+          case ":<":
+            query.where(column2, "<", value);
+            break;
+          case ":<=":
+            query.where(column2, "<=", value);
+            break;
+          case ":>":
+            query.where(column2, ">", value);
+            break;
+          case ":>=":
+            query.where(column2, ">=", value);
+            break;
+        }
+        break;
+      case "boolean":
+        switch (operator.operator) {
+          case ":":
+          case ":=":
+            query.where(column2, "=", value);
+            break;
+          case ":<":
+            query.where(column2, "<", value);
+            break;
+          case ":<=":
+            query.where(column2, "<=", value);
+            break;
+          case ":>":
+            query.where(column2, ">", value);
+            break;
+          case ":>=":
+            query.where(column2, ">=", value);
+            break;
+        }
+        break;
+    }
   }
-};
-const applyLuceneTagAst = (ast, query, attributesToColumns, primaryKey, tableName, allowedColumns) => {
-  const { expression, field, operator } = ast;
-  switch (field.type) {
-    case "ImplicitField":
-      applyLuceneImplicitFieldAst(
-        field,
-        expression,
-        operator,
-        query,
-        attributesToColumns,
-        primaryKey,
-        tableName,
-        allowedColumns
-      );
-      break;
-    case "Field":
-      applyLuceneFieldAst(
-        field,
-        expression,
-        operator,
-        query,
-        attributesToColumns,
-        primaryKey,
-        tableName,
-        allowedColumns
-      );
-      break;
+  applyLuceneRangeExpression(column2, expression, operator, query) {
+    const comparableMin = expression.range.minInclusive ? expression.range.min : expression.range.min + 1;
+    const comparableMax = expression.range.maxInclusive ? expression.range.max : expression.range.max - 1;
+    switch (operator.operator) {
+      case ":":
+      case ":=":
+        query.whereBetween(column2, [comparableMin, comparableMax]);
+        break;
+    }
   }
-};
-const applyLuceneUnaryOperatorAst = (ast, query, attributesToColumns, primaryKey, tableName, allowedColumns) => {
-  const operator = ast.operator;
-  if (operator === "NOT" || operator === "-") {
-    query.whereNot((subQuery) => {
-      applyLuceneAst(
-        ast.operand,
-        subQuery,
-        attributesToColumns,
-        primaryKey,
-        tableName,
-        allowedColumns
-      );
-    });
-  } else {
-    query.where((subQuery) => {
-      applyLuceneAst(
-        ast.operand,
-        subQuery,
-        attributesToColumns,
-        primaryKey,
-        tableName,
-        allowedColumns
-      );
-    });
+  applyLuceneRegexExpression(column2, expression, operator, query) {
+    let value = expression.value;
+    switch (__privateGet(this, _dialect)) {
+      case "mysql":
+      case "mariadb":
+        switch (operator.operator) {
+          case ":":
+          case ":=":
+            query.whereRaw(`?? REGEXP ?`, [column2, value]);
+            break;
+        }
+        break;
+      case "pg":
+      case "postgres":
+        switch (operator.operator) {
+          case ":":
+          case ":=":
+            query.whereRaw(`?? ~ ?`, [column2, value]);
+            break;
+        }
+        break;
+      case "oracle":
+      case "oracledb":
+      case "tedious":
+      case "mssql":
+        switch (operator.operator) {
+          case ":":
+          case ":=":
+            query.whereRaw(`REGEXP_LIKE(??, ?)`, [column2, value]);
+            break;
+        }
+        break;
+      case "sqlite3":
+      case "better-sqlite3":
+        throw new errors.E_LUCENE_REGEX_NOT_SUPPORTED();
+      default:
+        value = value.replace(/%/g, "\\%").replace(/_/g, "\\_");
+        value = value.replace(/\*/g, "%").replace(/\?/g, "_");
+        switch (operator.operator) {
+          case ":":
+          case ":=":
+            query.whereLike(column2, value);
+            break;
+        }
+        break;
+    }
   }
-};
-const applyLuceneAst = (ast, query, attributesToColumns, primaryKey, tableName, allowedColumns, throwOnInvalidType = false) => {
-  switch (ast.type) {
-    case "EmptyExpression":
-      break;
-    case "LogicalExpression":
-      applyLuceneLogicalExpressionAst(
-        ast,
-        query,
-        attributesToColumns,
-        primaryKey,
-        tableName,
-        allowedColumns
-      );
-      break;
-    case "ParenthesizedExpression":
-      applyLuceneParenthesizedExpressionAst(
-        ast,
-        query,
-        attributesToColumns,
-        primaryKey,
-        tableName,
-        allowedColumns
-      );
-      break;
-    case "Tag":
-      applyLuceneTagAst(ast, query, attributesToColumns, primaryKey, tableName, allowedColumns);
-      break;
-    case "UnaryOperator":
-      applyLuceneUnaryOperatorAst(
-        ast,
-        query,
-        attributesToColumns,
-        primaryKey,
-        tableName,
-        allowedColumns
-      );
-      break;
-    default:
-      if (throwOnInvalidType) {
-        throw new errors.E_LUCENE_INVALID_TYPE(ast.type);
+  static get(luceneQuery, connection, attributesToColumns, primaryKey, tableName, allowedColumns, model) {
+    let parsed;
+    try {
+      parsed = liqe.parse(luceneQuery);
+    } catch (error) {
+      if (error instanceof liqe.SyntaxError) {
+        throw new errors.E_LUCENE_SYNTAX_EXCEPTION(luceneQuery, error);
       }
-      break;
+      throw new errors.E_LUCENE_UNEXPECTED_EXCEPTION(error);
+    }
+    const query = connection.query().from(tableName);
+    const builder = new _LuceneLucidQueryBuilder(
+      connection,
+      query,
+      attributesToColumns,
+      primaryKey,
+      tableName,
+      allowedColumns,
+      model
+    );
+    builder.applyLuceneAst(parsed, query, true);
+    return query;
   }
 };
-const luceneToLucid = (luceneQuery, connection, attributesToColumns, primaryKey, tableName, allowedColumns) => {
-  let parsed;
-  try {
-    parsed = liqe.parse(luceneQuery);
-  } catch (error) {
-    if (error instanceof liqe.SyntaxError) {
-      throw new errors.E_LUCENE_SYNTAX_EXCEPTION(error);
+_attributesToColumns = new WeakMap();
+_allowedColumns = new WeakMap();
+_connection = new WeakMap();
+_dialect = new WeakMap();
+_primaryKey = new WeakMap();
+_tableName = new WeakMap();
+_model = new WeakMap();
+_LuceneLucidQueryBuilder_instances = new WeakSet();
+getSearchableColumns_fn = function() {
+  if (__privateGet(this, _model) && "$resourcefulColumns" in __privateGet(this, _model) && __privateGet(this, _model).$resourcefulColumns instanceof Map) {
+    const modelFields = [];
+    __privateGet(this, _model).$resourcefulColumns.forEach((_c2, k) => {
+      modelFields.push(k);
+    });
+    if ("$resourcefulRelationships" in __privateGet(this, _model) && __privateGet(this, _model).$resourcefulRelationships instanceof Map) {
+      __privateGet(this, _model).$resourcefulRelationships.forEach((_r, k) => {
+        modelFields.push(k);
+      });
     }
-    throw new errors.E_LUCENE_UNEXPECTED_EXCEPTION(error);
+    return Array.from(new Set(modelFields)).filter(
+      (f) => !__privateGet(this, _allowedColumns) || __privateGet(this, _allowedColumns).includes(f)
+    );
   }
-  const query = connection.query().from(tableName);
-  applyLuceneAst(parsed, query, attributesToColumns, primaryKey, tableName, allowedColumns, true);
-  return query;
+  return Object.entries(__privateGet(this, _attributesToColumns).all()).filter(([attr]) => !__privateGet(this, _allowedColumns) || __privateGet(this, _allowedColumns).includes(attr)).map(([, column2]) => column2);
+};
+let LuceneLucidQueryBuilder = _LuceneLucidQueryBuilder;
+const luceneToLucid = (luceneQuery, connection, attributesToColumns, primaryKey, tableName, allowedColumns, model) => {
+  return LuceneLucidQueryBuilder.get(
+    luceneQuery,
+    connection,
+    attributesToColumns,
+    primaryKey,
+    tableName,
+    allowedColumns,
+    model
+  );
 };
 var o = Object.defineProperty;
 var a = (t, s, r) => s in t ? o(t, s, { enumerable: true, configurable: true, writable: true, value: r }) : t[s] = r;
@@ -589,9 +628,388 @@ class l {
     ) : this.e[s] = []), this;
   }
 }
+class OpenApiSchemaService {
+  constructor() {
+    __privateAdd(this, _OpenApiSchemaService_instances);
+  }
+  /**
+   * Generates a complete OpenAPI schema object for a resourceful model.
+   *
+   * This method creates a comprehensive OpenAPI v3 schema representation of the model
+   * by processing the provided metadata schema. The metadata should already have
+   * field-level access control permissions evaluated for the given request context.
+   *
+   * @param resourcefulModelMetaSchema - The resourceful model metadata with ACL filtering applied
+   * @returns Complete OpenAPI schema object
+   *
+   * @example
+   * ```typescript
+   * const service = new OpenApiSchemaService()
+   * const schema = service.generateModelSchema(metaSchema)
+   * // Returns complete OpenAPI schema with accessible fields only
+   * ```
+   */
+  /* istanbul ignore next -- @preserve */
+  generateModelSchema(operation = "read", resourcefulModelMetaSchema, model) {
+    if (!errors.isObject(resourcefulModelMetaSchema) || !resourcefulModelMetaSchema.name || !decorator_utils.isResourcefulModel(model)) {
+      return {
+        type: "object",
+        properties: {},
+        required: []
+      };
+    }
+    const schema = {
+      type: "object",
+      title: resourcefulModelMetaSchema.name,
+      description: resourcefulModelMetaSchema.description,
+      externalDocs: resourcefulModelMetaSchema.externalDocs,
+      example: resourcefulModelMetaSchema.example,
+      properties: {}
+    };
+    /* istanbul ignore next -- @preserve */
+    Object.entries(resourcefulModelMetaSchema.properties).forEach(([propertyKey, propertyMeta]) => {
+      const resolvedColumnName = __privateMethod(this, _OpenApiSchemaService_instances, getFieldKey_fn).call(this, propertyKey, propertyMeta.lucidDefinitions);
+      if (null === resolvedColumnName) {
+        return;
+      }
+      switch (propertyMeta.kind) {
+        case "column": {
+          schema.properties[propertyKey] = this.generateColumnSchema(
+            propertyKey,
+            propertyMeta
+          );
+          return;
+        }
+        case "computedAccessor": {
+          schema.properties[propertyKey] = this.generateComputedAccessorSchema(
+            propertyKey,
+            propertyMeta
+          );
+          return;
+        }
+        case "relationship": {
+          const relatedSchema = this.generateRelationshipSchema(
+            propertyKey,
+            propertyMeta
+          );
+          if (relatedSchema) {
+            schema.properties[propertyKey] = relatedSchema;
+          }
+          return;
+        }
+      }
+    });
+    const requiredPropSet = /* @__PURE__ */ new Set();
+    Object.entries(schema.properties).forEach(([propertyKey, propertySchema]) => {
+      if (!errors.isObject(propertySchema) || "$ref" in propertySchema) {
+        return;
+      }
+      const isNullable = propertySchema.nullable === true;
+      if (!isNullable && ("read" === operation || !model.$resourcefulComputedAccessors.has(propertyKey) && !model.$resourcefulRelationships.has(propertyKey))) {
+        requiredPropSet.add(propertyKey);
+      }
+    });
+    schema.required = Array.from(requiredPropSet);
+    return schema;
+  }
+  /**
+   * Generates OpenAPI schema for a column property.
+   *
+   * This method converts resourceful column metadata into an OpenAPI schema object,
+   * properly extracting data type information and preserving all existing schema
+   * properties such as validation constraints, nullability, and access modifiers.
+   *
+   * @param propertyKey - The name of the column property
+   * @param propertyMeta - The resourceful metadata for the column
+   * @returns OpenAPI schema object for the column
+   *
+   * @example
+   * ```typescript
+   * const service = new OpenApiSchemaService()
+   * const schema = service.generateColumnSchema('name', columnMeta)
+   * // Returns: { type: 'string', minLength: 1, maxLength: 100, ... }
+   * ```
+   */
+  generateColumnSchema(propertyKey, propertyMeta) {
+    if (!errors.isObject(propertyMeta) || !propertyMeta.definition || !propertyMeta.lucidDefinitions) {
+      return {};
+    }
+    const dataTypeInfo = __privateMethod(this, _OpenApiSchemaService_instances, extractDataTypeInfo_fn).call(this, propertyMeta.definition.type);
+    const fieldKey = __privateMethod(this, _OpenApiSchemaService_instances, getFieldKey_fn).call(this, propertyKey, propertyMeta.lucidDefinitions);
+    const dataType = propertyMeta.definition.type;
+    const definition = propertyMeta.definition;
+    /* istanbul ignore next -- @preserve */
+    const schemaProperties = errors.stripUndefinedValuesFromObject({
+      // Core OpenAPI type information (properly extracted)
+      type: dataTypeInfo.type,
+      format: dataTypeInfo.format,
+      // Schema metadata
+      items: definition.items || dataType.items,
+      title: fieldKey || propertyKey,
+      description: definition.description,
+      default: "default" in definition ? definition.default : this.getDefaultValueFromPropertyMeta(propertyMeta),
+      // Numeric constraints (from data type or definition)
+      multipleOf: definition.multipleOf || dataType.multipleOf,
+      maximum: definition.maximum || dataType.maximum,
+      exclusiveMaximum: definition.exclusiveMaximum || dataType.exclusiveMaximum,
+      minimum: definition.minimum || dataType.minimum,
+      exclusiveMinimum: definition.exclusiveMinimum || dataType.exclusiveMinimum,
+      // String constraints (from data type or definition)
+      maxLength: definition.maxLength || dataType.maxLength,
+      minLength: definition.minLength || dataType.minLength,
+      pattern: definition.pattern || dataType.pattern,
+      // Object constraints (from data type or definition)
+      additionalProperties: definition.additionalProperties || dataType.additionalProperties,
+      maxProperties: definition.maxProperties || dataType.maxProperties,
+      minProperties: definition.minProperties || dataType.minProperties,
+      properties: definition.properties || dataType.properties,
+      // Array constraints (from data type or definition)
+      maxItems: definition.maxItems || dataType.maxItems,
+      minItems: definition.minItems || dataType.minItems,
+      uniqueItems: definition.uniqueItems || dataType.uniqueItems,
+      // Schema composition (from data type or definition)
+      allOf: definition.allOf || dataType.allOf,
+      oneOf: definition.oneOf || dataType.oneOf,
+      anyOf: definition.anyOf || dataType.anyOf,
+      not: definition.not || dataType.not,
+      // Validation and constraints (from data type or definition)
+      required: definition.required || dataType.required,
+      enum: definition.enum || dataType.enum,
+      nullable: definition.nullable !== void 0 ? definition.nullable : dataType.nullable || false,
+      // Access control
+      readOnly: propertyMeta.canRead && !propertyMeta.canWrite,
+      writeOnly: !propertyMeta.canRead && propertyMeta.canWrite,
+      // Documentation
+      externalDocs: definition.externalDocs,
+      example: definition.example
+    });
+    return schemaProperties;
+  }
+  /**
+   * Generates OpenAPI schema for a computed accessor property.
+   *
+   * This method converts resourceful computed accessor metadata into an OpenAPI
+   * schema object, applying the same data type extraction improvements as column
+   * schema generation while maintaining all existing functionality.
+   *
+   * @param propertyKey - The name of the computed accessor property
+   * @param propertyMeta - The resourceful metadata for the computed accessor
+   * @returns OpenAPI schema object for the computed accessor
+   *
+   * @example
+   * ```typescript
+   * const service = new OpenApiSchemaService()
+   * const schema = service.generateComputedAccessorSchema('fullName', accessorMeta)
+   * // Returns: { type: 'string', readOnly: true, ... }
+   * ```
+   */
+  generateComputedAccessorSchema(propertyKey, propertyMeta) {
+    if (!errors.isObject(propertyMeta) || !propertyMeta.definition || !propertyMeta.lucidDefinitions) {
+      return {};
+    }
+    const dataTypeInfo = __privateMethod(this, _OpenApiSchemaService_instances, extractDataTypeInfo_fn).call(this, propertyMeta.definition.type);
+    const fieldKey = __privateMethod(this, _OpenApiSchemaService_instances, getFieldKey_fn).call(this, propertyKey, propertyMeta.lucidDefinitions);
+    const dataType = propertyMeta.definition.type;
+    const definition = propertyMeta.definition;
+    /* istanbul ignore next -- @preserve */
+    const schemaProperties = errors.stripUndefinedValuesFromObject({
+      // Core OpenAPI type information (properly extracted)
+      type: dataTypeInfo.type,
+      format: dataTypeInfo.format,
+      // Schema metadata
+      items: definition.items || dataType.items,
+      title: fieldKey || propertyKey,
+      description: definition.description,
+      default: "default" in definition ? definition.default : this.getDefaultValueFromPropertyMeta(propertyMeta),
+      // Numeric constraints (from data type or definition)
+      multipleOf: definition.multipleOf || dataType.multipleOf,
+      maximum: definition.maximum || dataType.maximum,
+      exclusiveMaximum: definition.exclusiveMaximum || dataType.exclusiveMaximum,
+      minimum: definition.minimum || dataType.minimum,
+      exclusiveMinimum: definition.exclusiveMinimum || dataType.exclusiveMinimum,
+      // String constraints (from data type or definition)
+      maxLength: definition.maxLength || dataType.maxLength,
+      minLength: definition.minLength || dataType.minLength,
+      pattern: definition.pattern || dataType.pattern,
+      // Object constraints (from data type or definition)
+      additionalProperties: definition.additionalProperties || dataType.additionalProperties,
+      maxProperties: definition.maxProperties || dataType.maxProperties,
+      minProperties: definition.minProperties || dataType.minProperties,
+      properties: definition.properties || dataType.properties,
+      // Array constraints (from data type or definition)
+      maxItems: definition.maxItems || dataType.maxItems,
+      minItems: definition.minItems || dataType.minItems,
+      uniqueItems: definition.uniqueItems || dataType.uniqueItems,
+      // Schema composition (from data type or definition)
+      allOf: definition.allOf || dataType.allOf,
+      oneOf: definition.oneOf || dataType.oneOf,
+      anyOf: definition.anyOf || dataType.anyOf,
+      not: definition.not || dataType.not,
+      // Validation and constraints (from data type or definition)
+      required: definition.required || dataType.required,
+      enum: definition.enum || dataType.enum,
+      nullable: definition.nullable !== void 0 ? definition.nullable : dataType.nullable || false,
+      // Access control
+      readOnly: propertyMeta.canRead && !propertyMeta.canWrite,
+      writeOnly: !propertyMeta.canRead && propertyMeta.canWrite,
+      // Documentation
+      externalDocs: definition.externalDocs,
+      example: definition.example
+    });
+    return schemaProperties;
+  }
+  /**
+   * Generates OpenAPI schema for a relationship property.
+   *
+   * This method converts resourceful relationship metadata into an OpenAPI
+   * reference object, preserving existing relationship reference generation
+   * logic and ensuring proper handling of related model references.
+   *
+   * @param propertyKey - The name of the relationship property
+   * @param propertyMeta - The resourceful metadata for the relationship
+   * @returns OpenAPI reference object for the relationship, or undefined if not applicable
+   *
+   * @example
+   * ```typescript
+   * const service = new OpenApiSchemaService()
+   * const schema = service.generateRelationshipSchema('user', relationshipMeta)
+   * // Returns: { $ref: '#/components/schemas/User' }
+   * ```
+   */
+  generateRelationshipSchema(_propertyKey, propertyMeta) {
+    if (!errors.isObject(propertyMeta) || !propertyMeta.definition || !propertyMeta.lucidDefinitions || !propertyMeta.relatedModel) {
+      return void 0;
+    }
+    const relatedModel = propertyMeta.relatedModel();
+    /* istanbul ignore if -- @preserve */
+    if (!relatedModel) {
+      return void 0;
+    }
+    /* istanbul ignore if -- @preserve */
+    if (!decorator_utils.isResourcefulModel(relatedModel)) {
+      return void 0;
+    }
+    const ref2 = `#/components/schemas/${relatedModel.$resourcefulName}`;
+    return {
+      $ref: ref2
+    };
+  }
+  /**
+   * Extracts default value from property metadata using Joi description.
+   *
+   * This protected method provides access to the default value extraction logic
+   * that was previously part of the mixin. It examines the Joi validator
+   * description to find default values specified in the schema.
+   *
+   * @param propertyMeta - The resourceful metadata containing the validator
+   * @returns The default value if found, undefined otherwise
+   *
+   * @example
+   * ```typescript
+   * const service = new OpenApiSchemaService()
+   * const defaultValue = service.getDefaultValueFromPropertyMeta(propertyMeta)
+   * ```
+   */
+  getDefaultValueFromPropertyMeta(propertyMeta) {
+    const joiDescription = propertyMeta.validator.describe();
+    /* istanbul ignore if -- @preserve */
+    if (errors.isObject(joiDescription) && "flags" in joiDescription && errors.isObject(joiDescription.flags) && "default" in joiDescription.flags) {
+      return joiDescription.flags.default;
+    }
+    /* istanbul ignore next -- @preserve */
+    return void 0;
+  }
+}
+_OpenApiSchemaService_instances = new WeakSet();
+/**
+ * Gets the field key for a property, handling serializeAs transformation.
+ *
+ * This private method extracts the appropriate field name for a property,
+ * taking into account the serializeAs option from Lucid model definitions.
+ * Returns null if the field cannot be read (following Lucid's serializeAs behavior).
+ *
+ * @param key - The original property key
+ * @param definition - The Lucid model definition (column, computed, or relation)
+ * @returns The field key to use, the original key if no transformation is needed, or null if field cannot be read
+ */
+getFieldKey_fn = function(key, definition) {
+  if (definition.serializeAs === null) {
+    return null;
+  }
+  /* istanbul ignore if -- @preserve */
+  if (errors.isString(definition.serializeAs)) {
+    return definition.serializeAs;
+  }
+  /* istanbul ignore next -- @preserve */
+  return key;
+};
+/**
+ * Extracts OpenAPI type and format information from resourceful data types.
+ *
+ * This private method handles the mapping from resourceful data type instances
+ * to their corresponding OpenAPI type and format specifications. It properly
+ * handles all supported resourceful data types and provides appropriate
+ * fallback behavior for unknown types.
+ *
+ * @param dataType - The resourceful data type instance to extract information from
+ * @returns Object containing the OpenAPI type and optional format
+ *
+ * @example
+ * ```typescript
+ * const info = this.#extractDataTypeInfo(ResourcefulStringType())
+ * // Returns: { type: 'string' }
+ *
+ * const info = this.#extractDataTypeInfo(ResourcefulDateTimeType())
+ * // Returns: { type: 'string', format: 'date-time' }
+ * ```
+ */
+extractDataTypeInfo_fn = function(dataType) {
+  let baseType;
+  try {
+    baseType = dataType.type;
+  } catch (error) {
+    /* istanbul ignore next -- @preserve */
+    return { type: "string" };
+  }
+  const format = "format" in dataType && typeof dataType.format === "string" ? dataType.format : void 0;
+  /* istanbul ignore next -- @preserve */
+  switch (baseType) {
+    case "string": {
+      if (format) {
+        return { type: "string", format };
+      }
+      return { type: "string" };
+    }
+    case "number": {
+      if (format === "float" || format === "double") {
+        return { type: "number", format };
+      }
+      return { type: "number" };
+    }
+    case "integer": {
+      if (format === "int32" || format === "int64") {
+        return { type: "integer", format };
+      }
+      return { type: "integer" };
+    }
+    case "boolean": {
+      return { type: "boolean" };
+    }
+    case "object": {
+      return { type: "object" };
+    }
+    case "array": {
+      return { type: "array" };
+    }
+    default: {
+      /* istanbul ignore next -- @preserve */
+      return { type: "string" };
+    }
+  }
+};
 const ResourcefulErrorHandlerMethod = ["bubble", "pass", "fail"];
 const getFieldKey = (key, definition) => {
-  if (decorator_utils.isString(definition.serializeAs)) {
+  if (errors.isString(definition.serializeAs)) {
     return definition.serializeAs;
   }
   return key;
@@ -614,6 +1032,10 @@ function withResourceful(options = {}) {
         list: joi.joi.array().items(joi.joi.function()).default([]),
         access: joi.joi.array().items(joi.joi.function()).default([])
       }).default({}),
+      payloadValidationSchemaBuilders: joi.joi.object({
+        create: joi.joi.array().items(joi.joi.function()).default([]),
+        update: joi.joi.array().items(joi.joi.function()).default([])
+      }).default({ create: [], update: [] }),
       description: joi.joi.string().optional(),
       externalDocs: joi.joi.object({
         description: joi.joi.string().optional(),
@@ -672,6 +1094,7 @@ function withResourceful(options = {}) {
           Array.from(this.$resourcefulColumns.entries()),
           async ([propertyKey, columnDefinition]) => {
             const lucidDefinitions = this.$getColumn(propertyKey);
+            /* istanbul ignore if -- @preserve */
             if (!lucidDefinitions) return;
             const resourcefulModelColumnMetaSchema = {
               propertyKey,
@@ -709,6 +1132,7 @@ function withResourceful(options = {}) {
           Array.from(this.$resourcefulComputedAccessors.entries()),
           async ([propertyKey, computedAccessorDefinition]) => {
             const lucidDefinitions = this.$getComputed(propertyKey);
+            /* istanbul ignore if -- @preserve */
             if (!lucidDefinitions) return;
             const resourcefulModelComputedAccessorMetaSchema = {
               propertyKey,
@@ -736,6 +1160,7 @@ function withResourceful(options = {}) {
                 computedAccessorDefinition.writable
               )
             };
+            /* istanbul ignore if -- @preserve */
             if (!resourcefulModelComputedAccessorMetaSchema.canRead && !resourcefulModelComputedAccessorMetaSchema.canWrite)
               return;
             resourcefulModelMetaSchema.properties[propertyKey] = resourcefulModelComputedAccessorMetaSchema;
@@ -748,6 +1173,7 @@ function withResourceful(options = {}) {
           Array.from(this.$resourcefulRelationships.entries()),
           async ([propertyKey, relationshipDefinition]) => {
             const lucidDefinitions = this.$getRelation(propertyKey);
+            /* istanbul ignore if -- @preserve */
             if (!lucidDefinitions) return;
             const resourcefulModelRelationshipMetaSchema = {
               propertyKey,
@@ -766,6 +1192,7 @@ function withResourceful(options = {}) {
               validator: joi.joi.forbidden(),
               relatedModel: relationshipDefinition.relatedModel
             };
+            /* istanbul ignore if -- @preserve */
             if (!resourcefulModelRelationshipMetaSchema.canRead && !resourcefulModelRelationshipMetaSchema.canWrite)
               return;
             resourcefulModelMetaSchema.properties[propertyKey] = resourcefulModelRelationshipMetaSchema;
@@ -781,8 +1208,11 @@ function withResourceful(options = {}) {
           return joi.joi.any().forbidden();
         }
         const baseValidator = this.$getPropertyBaseValidator(datatype, nullable, kind, writable);
+        let retValidator = baseValidator;
         if (Array.isArray(validationScopes) && validationScopes.length > 0) {
           validationScopes.forEach((validationScope) => {
+            /* istanbul ignore if -- @preserve */
+            if (retValidator !== baseValidator) return;
             try {
               validationScope(baseValidator);
             } catch (err) {
@@ -800,12 +1230,13 @@ function withResourceful(options = {}) {
                 case "pass":
                   break;
                 case "fail":
-                  return joi.joi.any().forbidden();
+                  retValidator = joi.joi.any().forbidden();
+                  break;
               }
             }
           });
         }
-        return baseValidator;
+        return retValidator;
       }
       static $getPropertyBaseValidator(datatype, nullable, kind, writable = false) {
         if ("relationship" === kind || "computedAccessor" === kind && !writable) {
@@ -813,132 +1244,178 @@ function withResourceful(options = {}) {
         }
         nullable = nullable || "boolean" === typeof datatype.nullable && datatype.nullable;
         switch (true) {
-          case datatype instanceof definitions.ResourcefulStringType: {
-            const d = datatype;
-            const r = joi.joi.string().min(d.minLength).max(d.maxLength);
-            if (d.pattern) {
-              r.pattern(new RegExp(d.pattern));
-            }
-            if (d.enum) {
-              r.valid(...d.enum);
-            }
+          case decorator_utils.isResourcefulDateType(datatype): {
+            let r = joi.joi.date().iso();
             if (nullable) {
-              r.allow(null);
+              return joi.joi.alternatives(r, joi.joi.any().valid(null));
             }
             return r;
           }
-          case datatype instanceof definitions.ResourcefulDateType: {
-            const r = joi.joi.date().iso();
+          case decorator_utils.isResourcefulDateTimeType(datatype): {
+            let r = joi.joi.date().iso();
             if (nullable) {
-              r.allow(null);
+              return joi.joi.alternatives(r, joi.joi.any().valid(null));
             }
             return r;
           }
-          case datatype instanceof definitions.ResourcefulDateTimeType: {
-            const r = joi.joi.date().iso();
+          case decorator_utils.isResourcefulBinaryType(datatype): {
+            const d = datatype;
+            const min2 = "number" === typeof d.minLength ? Math.abs(d.minLength) : 0;
+            const max2 = "number" === typeof d.maxLength ? Math.abs(d.maxLength) : Number.MAX_SAFE_INTEGER;
+            let r = joi.joi.string().min(min2).max(max2);
             if (nullable) {
-              r.allow(null);
+              return joi.joi.alternatives(r, joi.joi.any().valid(null));
             }
             return r;
           }
-          case datatype instanceof definitions.ResourcefulBinaryType: {
+          case decorator_utils.isResourcefulStringType(datatype): {
             const d = datatype;
-            const r = joi.joi.string();
-            if (nullable) {
-              r.allow(null);
+            let r = joi.joi.string().min(d.minLength).max(d.maxLength);
+            if (d.pattern) {
+              r = r.concat(r.pattern(new RegExp(d.pattern)));
             }
-            if (d.minLength !== void 0) {
-              r.min(d.minLength);
+            if (d.enum) {
+              r = r.concat(joi.joi.string().valid(...d.enum));
             }
-            if (d.maxLength !== void 0) {
-              r.max(d.maxLength);
+            if (nullable) {
+              return joi.joi.alternatives(r, joi.joi.any().valid(null));
             }
             return r;
           }
-          case datatype instanceof definitions.ResourcefulNumberType: {
+          case decorator_utils.isResourcefulIntegerType(datatype): {
             const d = datatype;
-            const r = joi.joi.number();
-            if (nullable) {
-              r.allow(null);
-            }
-            r.multiple(d.multipleOf);
+            let r = joi.joi.number();
+            r = r.concat(joi.joi.number().integer().multiple(d.multipleOf));
             if (d.exclusiveMaximum) {
-              r.less(d.maximum);
+              r = r.concat(joi.joi.number().less(d.maximum));
             } else {
-              r.max(d.maximum);
+              r = r.concat(joi.joi.number().max(d.maximum));
             }
             if (d.exclusiveMinimum) {
-              r.greater(d.minimum);
+              r = r.concat(joi.joi.number().greater(d.minimum));
             } else {
-              r.min(d.minimum);
+              r = r.concat(joi.joi.number().min(d.minimum));
+            }
+            if (nullable) {
+              return joi.joi.alternatives(r, joi.joi.any().valid(null));
             }
             return r;
           }
-          case datatype instanceof definitions.ResourcefulIntegerType: {
+          case decorator_utils.isResourcefulBigintType(datatype): {
             const d = datatype;
-            const r = joi.joi.number();
-            if (nullable) {
-              r.allow(null);
+            if ("undefined" === typeof d.minimum) {
+              d.minimum = 0n;
+            }
+            if ("undefined" === typeof d.maximum) {
+              d.maximum = BigInt(Number.MAX_SAFE_INTEGER);
             }
-            r.integer().multiple(d.multipleOf);
+            if ("undefined" === typeof d.multipleOf) {
+              d.multipleOf = 1n;
+            }
+            let b = joi.joi.bigint();
+            let i = joi.joi.number().integer();
+            b = b.concat(
+              joi.joi.bigint().multiple("number" === typeof d.multipleOf ? BigInt(d.multipleOf) : d.multipleOf)
+            );
+            i = i.concat(
+              joi.joi.number().multiple(
+                "bigint" === typeof d.multipleOf ? Number.parseInt(d.multipleOf.toString()) : d.multipleOf
+              )
+            );
             if (d.exclusiveMaximum) {
-              r.less(d.maximum);
+              if (["number", "bigint"].includes(typeof d.maximum)) {
+                b = b.concat(
+                  joi.joi.bigint().less("number" === typeof d.maximum ? BigInt(d.maximum) : d.maximum)
+                );
+              }
+              i = i.concat(
+                joi.joi.number().less(
+                  "bigint" === typeof d.maximum ? Number.parseInt(d.maximum.toString()) : d.maximum
+                )
+              );
             } else {
-              r.max(d.maximum);
+              if (["number", "bigint"].includes(typeof d.maximum)) {
+                b = b.concat(
+                  joi.joi.bigint().max("number" === typeof d.maximum ? BigInt(d.maximum) : d.maximum)
+                );
+              }
+              i = i.concat(
+                joi.joi.number().max(
+                  "bigint" === typeof d.maximum ? Number.parseInt(d.maximum.toString()) : d.maximum
+                )
+              );
             }
             if (d.exclusiveMinimum) {
-              r.greater(d.minimum);
+              b = b.concat(
+                joi.joi.bigint().greater("number" === typeof d.minimum ? BigInt(d.minimum) : d.minimum)
+              );
+              i = i.concat(
+                joi.joi.number().greater(
+                  "bigint" === typeof d.minimum ? Number.parseInt(d.minimum.toString()) : d.minimum
+                )
+              );
             } else {
-              r.min(d.minimum);
+              b = b.concat(
+                joi.joi.bigint().min("number" === typeof d.minimum ? BigInt(d.minimum) : d.minimum)
+              );
+              i = i.concat(
+                joi.joi.number().min(
+                  "bigint" === typeof d.minimum ? Number.parseInt(d.minimum.toString()) : d.minimum
+                )
+              );
+            }
+            let r = joi.joi.alternatives(b, i);
+            if (nullable) {
+              return joi.joi.alternatives(r, joi.joi.any().valid(null));
             }
             return r;
           }
-          case datatype instanceof definitions.ResourcefulBigintType: {
+          case decorator_utils.isResourcefulUnsignedIntegerType(datatype): {
             const d = datatype;
-            const r = joi.joi.bigint();
-            if (nullable) {
-              r.allow(null);
-            }
-            r.multiple(d.multipleOf);
+            let r = joi.joi.number().unsafe();
+            r = r.concat(joi.joi.number().integer().multiple(d.multipleOf));
             if (d.exclusiveMaximum) {
-              r.less(d.maximum);
+              r = r.concat(joi.joi.number().less(d.maximum));
             } else {
-              r.max(d.maximum);
+              r = r.concat(joi.joi.number().max(d.maximum));
             }
             if (d.exclusiveMinimum) {
-              r.greater(d.minimum);
+              r = r.concat(joi.joi.number().greater(d.minimum));
             } else {
-              r.min(d.minimum);
+              r = r.concat(joi.joi.number().min(d.minimum));
+            }
+            if (nullable) {
+              return joi.joi.alternatives(r, joi.joi.any().valid(null));
             }
             return r;
           }
-          case datatype instanceof definitions.ResourcefulUnsignedIntegerType: {
+          case decorator_utils.isResourcefulNumberType(datatype): {
             const d = datatype;
-            const r = joi.joi.number().unsafe();
-            if (nullable) {
-              r.allow(null);
-            }
-            r.integer().multiple(d.multipleOf);
+            let r = joi.joi.number();
+            r = r.concat(joi.joi.number().multiple(d.multipleOf));
             if (d.exclusiveMaximum) {
-              r.less(d.maximum);
+              r = r.concat(joi.joi.number().less(d.maximum));
             } else {
-              r.max(d.maximum);
+              r = r.concat(joi.joi.number().max(d.maximum));
             }
             if (d.exclusiveMinimum) {
-              r.greater(d.minimum);
+              r = r.concat(joi.joi.number().greater(d.minimum));
             } else {
-              r.min(d.minimum);
+              r = r.concat(joi.joi.number().min(d.minimum));
+            }
+            if (nullable) {
+              return joi.joi.alternatives(r, joi.joi.any().valid(null));
             }
             return r;
           }
-          case datatype instanceof definitions.ResourcefulBooleanType: {
-            const r = joi.joi.boolean();
+          case decorator_utils.isResourcefulBooleanType(datatype): {
+            let r = joi.joi.boolean();
             if (nullable) {
-              r.allow(null);
+              return joi.joi.alternatives(r, joi.joi.any().valid(null));
             }
             return r;
           }
-          case datatype instanceof definitions.ResourcefulObjectType: {
+          case decorator_utils.isResourcefulObjectType(datatype): {
             const d = datatype;
             const objectSchema = {};
             Object.entries(d.properties).forEach(([propKey, propDef]) => {
@@ -952,7 +1429,7 @@ function withResourceful(options = {}) {
                     !(item.readOnly || false)
                   )
                 );
-                propValidator = joi.joi.alternatives().try(...alternatives);
+                propValidator = joi.joi.alternatives(...alternatives);
               } else if ("allOf" in propDef) {
                 const schemas = propDef.allOf.map(
                   (item) => this.$getPropertyBaseValidator(
@@ -972,7 +1449,7 @@ function withResourceful(options = {}) {
                     !(item.readOnly || false)
                   )
                 );
-                propValidator = joi.joi.alternatives().try(...alternatives);
+                propValidator = joi.joi.alternatives(...alternatives);
               } else if ("not" in propDef) {
                 const notSchemas = propDef.not.map(
                   (item) => this.$getPropertyBaseValidator(
@@ -982,7 +1459,12 @@ function withResourceful(options = {}) {
                     !(item.readOnly || false)
                   )
                 );
-                propValidator = joi.joi.any().not(...notSchemas);
+                propValidator = joi.joi.any();
+                notSchemas.forEach((notSchema) => {
+                  propValidator = propValidator.concat(
+                    joi.joi.when(notSchema, { then: joi.joi.forbidden() })
+                  );
+                });
               } else {
                 propValidator = this.$getPropertyBaseValidator(
                   propDef,
@@ -990,44 +1472,46 @@ function withResourceful(options = {}) {
                   kind,
                   !(propDef.readOnly || false)
                 );
+                if (Array.isArray(d.required) && d.required.includes(propKey)) {
+                  propValidator = propValidator.concat(joi.joi.any().required());
+                }
               }
               if (d.required && d.required.includes(propKey)) {
                 propValidator.required();
               }
               objectSchema[propKey] = propValidator;
             });
-            const r = joi.joi.object(objectSchema);
-            if (nullable) {
-              r.allow(null);
-            }
+            let r = joi.joi.object(objectSchema);
             if (d.minProperties !== void 0) {
-              r.min(d.minProperties);
+              r = r.concat(joi.joi.object().min(d.minProperties));
             }
             if (d.maxProperties !== void 0) {
-              r.max(d.maxProperties);
+              r = r.concat(joi.joi.object().max(d.maxProperties));
             }
             if (decorator_utils.isObject(d.additionalProperties)) {
               const additionalPropertiesType = d.additionalProperties;
-              r.pattern(
-                joi.joi.string(),
-                this.$getPropertyBaseValidator(
-                  additionalPropertiesType,
-                  additionalPropertiesType.nullable || false,
-                  kind,
-                  !(additionalPropertiesType.readOnly || false)
+              r = r.concat(
+                joi.joi.object().pattern(
+                  joi.joi.string(),
+                  this.$getPropertyBaseValidator(
+                    additionalPropertiesType,
+                    additionalPropertiesType.nullable || false,
+                    kind,
+                    !(additionalPropertiesType.readOnly || false)
+                  )
                 )
               );
             } else {
-              r.unknown(true === d.additionalProperties);
+              r = r.concat(joi.joi.object().unknown(true === d.additionalProperties));
+            }
+            if (nullable) {
+              return joi.joi.alternatives(r, joi.joi.any().valid(null));
             }
             return r;
           }
-          case datatype instanceof definitions.ResourcefulArrayType: {
+          case decorator_utils.isResourcefulArrayType(datatype): {
             const d = datatype;
-            const r = joi.joi.array();
-            if (nullable) {
-              r.allow(null);
-            }
+            let r = joi.joi.array();
             let itemValidator;
             if ("oneOf" in d.items) {
               const alternatives = d.items.oneOf.map(
@@ -1038,7 +1522,7 @@ function withResourceful(options = {}) {
                   !(item.readOnly || false)
                 )
               );
-              itemValidator = joi.joi.alternatives().try(...alternatives);
+              itemValidator = joi.joi.alternatives(...alternatives);
             } else if ("allOf" in d.items) {
               const schemas = d.items.allOf.map(
                 (item) => this.$getPropertyBaseValidator(
@@ -1058,7 +1542,7 @@ function withResourceful(options = {}) {
                   !(item.readOnly || false)
                 )
               );
-              itemValidator = joi.joi.alternatives().try(...alternatives);
+              itemValidator = joi.joi.alternatives(...alternatives);
             } else if ("not" in d.items) {
               const notSchemas = d.items.not.map(
                 (item) => this.$getPropertyBaseValidator(
@@ -1068,7 +1552,10 @@ function withResourceful(options = {}) {
                   !(item.readOnly || false)
                 )
               );
-              itemValidator = joi.joi.any().not(...notSchemas);
+              itemValidator = joi.joi.any();
+              notSchemas.forEach((notSchema) => {
+                itemValidator = itemValidator.concat(joi.joi.when(notSchema, { then: joi.joi.forbidden() }));
+              });
             } else {
               itemValidator = this.$getPropertyBaseValidator(
                 d.items,
@@ -1077,15 +1564,18 @@ function withResourceful(options = {}) {
                 !(d.items.readOnly || false)
               );
             }
-            r.items(itemValidator);
+            r = r.concat(joi.joi.array().items(itemValidator));
             if (d.minItems !== void 0) {
-              r.min(d.minItems);
+              r = r.concat(joi.joi.array().min(d.minItems));
             }
             if (d.maxItems !== void 0) {
-              r.max(d.maxItems);
+              r = r.concat(joi.joi.array().max(d.maxItems));
             }
             if (d.uniqueItems) {
-              r.unique();
+              r = r.concat(joi.joi.array().unique());
+            }
+            if (nullable) {
+              return joi.joi.alternatives(r, joi.joi.any().valid(null));
             }
             return r;
           }
@@ -1135,151 +1625,14 @@ function withResourceful(options = {}) {
         );
         return results.every((result) => result === true);
       }
-      static async $asOpenApiSchemaObject(ctx, app) {
+      static async $asOpenApiSchemaObject(ctx, app, operation = "read") {
         const resourcefulModelMetaSchema = await this.$getAsResourcefulForContext(ctx, app);
-        const ret = {
-          type: "object",
-          title: resourcefulModelMetaSchema.name,
-          description: resourcefulModelMetaSchema.description,
-          externalDocs: resourcefulModelMetaSchema.externalDocs,
-          example: resourcefulModelMetaSchema.example,
-          properties: {}
-        };
-        Object.entries(resourcefulModelMetaSchema.properties).forEach(
-          ([propertyKey, propertyMeta]) => {
-            switch (propertyMeta.kind) {
-              case "column": {
-                ret.properties[propertyKey] = this.$resourcefulModelColumnMetaToOpenApiSchema(
-                  propertyKey,
-                  propertyMeta
-                );
-                return;
-              }
-              case "computedAccessor": {
-                ret.properties[propertyKey] = this.$resourcefulModelComputedAccessorMetaToOpenApiSchema(
-                  propertyKey,
-                  propertyMeta
-                );
-                return;
-              }
-              case "relationship": {
-                const relatedSchema = this.$resourcefulModelRelationshipMetaToOpenApiSchema(
-                  propertyKey,
-                  propertyMeta
-                );
-                if (relatedSchema) {
-                  ret.properties[propertyKey] = relatedSchema;
-                }
-                return;
-              }
-            }
-          }
-        );
-        const requiredPropSet = /* @__PURE__ */ new Set();
-        Object.entries(ret.properties).forEach(([propertyKey, schema]) => {
-          if (!decorator_utils.isObject(schema) || "$ref" in schema || !("nullable" in schema) || schema.nullable)
-            return;
-          requiredPropSet.add(propertyKey);
-        });
-        ret.required = Array.from(requiredPropSet);
-        return ret;
-      }
-      static $getDefaultValueFromPropertyMeta(propertyMeta) {
-        const joiDescription = propertyMeta.validator.describe();
-        if (decorator_utils.isObject(joiDescription) && "flags" in joiDescription && decorator_utils.isObject(joiDescription.flags) && "default" in joiDescription.flags) {
-          return joiDescription.flags.default;
-        }
-      }
-      static $resourcefulModelColumnMetaToOpenApiSchema(propertyKey, propertyMeta) {
-        const ret = stripUndefinedValuesFromObject({
-          items: propertyMeta.definition.items,
-          title: getFieldKey(propertyKey, propertyMeta.lucidDefinitions) || propertyKey,
-          description: propertyMeta.definition.description,
-          format: propertyMeta.definition.format,
-          default: this.$getDefaultValueFromPropertyMeta(propertyMeta),
-          multipleOf: propertyMeta.definition.multipleOf,
-          maximum: propertyMeta.definition.maximum,
-          exclusiveMaximum: propertyMeta.definition.exclusiveMaximum,
-          minimum: propertyMeta.definition.minimum,
-          exclusiveMinimum: propertyMeta.definition.exclusiveMinimum,
-          maxLength: propertyMeta.definition.maxLength,
-          minLength: propertyMeta.definition.minLength,
-          pattern: propertyMeta.definition.pattern,
-          additionalProperties: propertyMeta.definition.additionalProperties,
-          maxItems: propertyMeta.definition.maxItems,
-          minItems: propertyMeta.definition.minItems,
-          uniqueItems: propertyMeta.definition.uniqueItems,
-          maxProperties: propertyMeta.definition.maxProperties,
-          minProperties: propertyMeta.definition.minProperties,
-          required: propertyMeta.definition.required,
-          enum: propertyMeta.definition.enum,
-          properties: propertyMeta.definition.properties,
-          allOf: propertyMeta.definition.allOf,
-          oneOf: propertyMeta.definition.oneOf,
-          anyOf: propertyMeta.definition.anyOf,
-          not: propertyMeta.definition.not,
-          nullable: propertyMeta.definition.nullable,
-          readOnly: propertyMeta.canRead && !propertyMeta.canWrite,
-          writeOnly: !propertyMeta.canRead && propertyMeta.canWrite,
-          externalDocs: propertyMeta.definition.externalDocs,
-          example: propertyMeta.definition.example,
-          ...propertyMeta.definition.type
-        });
-        return ret;
-      }
-      static $resourcefulModelComputedAccessorMetaToOpenApiSchema(propertyKey, propertyMeta) {
-        const ret = stripUndefinedValuesFromObject({
-          items: propertyMeta.definition.items,
-          title: getFieldKey(propertyKey, propertyMeta.lucidDefinitions) || propertyKey,
-          description: propertyMeta.definition.description,
-          format: propertyMeta.definition.format,
-          default: this.$getDefaultValueFromPropertyMeta(propertyMeta),
-          multipleOf: propertyMeta.definition.multipleOf,
-          maximum: propertyMeta.definition.maximum,
-          exclusiveMaximum: propertyMeta.definition.exclusiveMaximum,
-          minimum: propertyMeta.definition.minimum,
-          exclusiveMinimum: propertyMeta.definition.exclusiveMinimum,
-          maxLength: propertyMeta.definition.maxLength,
-          minLength: propertyMeta.definition.minLength,
-          pattern: propertyMeta.definition.pattern,
-          additionalProperties: propertyMeta.definition.additionalProperties,
-          maxItems: propertyMeta.definition.maxItems,
-          minItems: propertyMeta.definition.minItems,
-          uniqueItems: propertyMeta.definition.uniqueItems,
-          maxProperties: propertyMeta.definition.maxProperties,
-          minProperties: propertyMeta.definition.minProperties,
-          required: propertyMeta.definition.required,
-          enum: propertyMeta.definition.enum,
-          properties: propertyMeta.definition.properties,
-          allOf: propertyMeta.definition.allOf,
-          oneOf: propertyMeta.definition.oneOf,
-          anyOf: propertyMeta.definition.anyOf,
-          not: propertyMeta.definition.not,
-          nullable: propertyMeta.definition.nullable,
-          readOnly: propertyMeta.canRead && !propertyMeta.canWrite,
-          writeOnly: !propertyMeta.canRead && propertyMeta.canWrite,
-          externalDocs: propertyMeta.definition.externalDocs,
-          example: propertyMeta.definition.example,
-          ...propertyMeta.definition.type
-        });
-        return ret;
-      }
-      static $resourcefulModelRelationshipMetaToOpenApiSchema(_propertyKey, propertyMeta) {
-        const relatedModel = propertyMeta.relatedModel();
-        if (!relatedModel) {
-          return void 0;
-        }
-        if (!decorator_utils.isResourcefulModel(relatedModel)) {
-          return void 0;
-        }
-        const ref2 = `#/components/schemas/${relatedModel.$resourcefulName}`;
-        return {
-          $ref: ref2
-        };
+        const service = new OpenApiSchemaService();
+        return service.generateModelSchema(operation, resourcefulModelMetaSchema, this);
       }
       static async $resourcefulCheckAccess(config) {
         const { ctx, app, operation, instance } = config;
-        const allowedFieldsMap = /* @__PURE__ */ new Map();
+        const allowedSerializedMap = /* @__PURE__ */ new Map();
         const allowedColumnsMap = /* @__PURE__ */ new Map();
         const mixinAccessControlFilters = validatedOptions.accessControlFilters[operation];
         if (mixinAccessControlFilters) {
@@ -1291,37 +1644,72 @@ function withResourceful(options = {}) {
             return {
               isForbidden: true,
               message: "Access denied by Mixin ACLs.",
-              allowedFieldsMap: void 0
+              allowedSerializedMap: void 0
             };
           }
         }
-        if (operation === decorator_utils.CRUDOperationsEnum.DELETE) {
-          return { isForbidden: false, allowedFieldsMap, allowedColumnsMap };
+        if (operation === errors.CRUDOperationsEnum.DELETE) {
+          return {
+            isForbidden: false,
+            allowedSerializedMap,
+            allowedColumnsMap
+          };
         }
         const columnsOptions = this.$resourcefulColumns.values();
-        const aclOperation = decorator_utils.operationCRUDToACL(operation);
-        const addColumnOptionToAllowedFieldsMap = (propertyKey) => {
+        const aclOperation = errors.operationCRUDToACL(operation);
+        const addColumnOptionToallowedSerializedMap = (propertyKey) => {
           const serializedName = this.$keys.attributesToSerialized.resolve(propertyKey);
           const columnName = this.$keys.serializedToColumns.resolve(serializedName);
-          if (serializedName) {
-            allowedFieldsMap.set(propertyKey, true);
-          }
-          if (columnName) {
-            allowedColumnsMap.set(columnName, true);
+          if (aclOperation === errors.ACLOperationsEnum.WRITE && serializedName === null) {
+            if (columnName) {
+              allowedSerializedMap.set(columnName, true);
+              allowedColumnsMap.set(columnName, true);
+            }
+          } else if ("string" === typeof serializedName) {
+            allowedSerializedMap.set(serializedName, true);
+            if (columnName) {
+              allowedColumnsMap.set(columnName, true);
+            }
           }
         };
         for (const columnOptions of columnsOptions) {
-          const propertyACLFilters = aclOperation === decorator_utils.ACLOperationsEnum.READ ? columnOptions.readAccessControlFilters : columnOptions.writeAccessControlFilters;
+          const propertyACLFilters = aclOperation === errors.ACLOperationsEnum.READ ? columnOptions.readAccessControlFilters : columnOptions.writeAccessControlFilters;
           if (!propertyACLFilters) {
-            addColumnOptionToAllowedFieldsMap(columnOptions.propertyKey);
+            addColumnOptionToallowedSerializedMap(columnOptions.propertyKey);
             continue;
           }
           const isAllowed = await this.$evaluatePropertyAccess(ctx, app, propertyACLFilters);
           if (isAllowed) {
-            addColumnOptionToAllowedFieldsMap(columnOptions.propertyKey);
+            addColumnOptionToallowedSerializedMap(columnOptions.propertyKey);
+          }
+        }
+        if (aclOperation === errors.ACLOperationsEnum.READ) {
+          const computedAccessorsOptions = this.$resourcefulComputedAccessors.values();
+          for (const computedAccessorOptions of computedAccessorsOptions) {
+            const propertyACLFilters = computedAccessorOptions.readAccessControlFilters;
+            if (!propertyACLFilters) {
+              allowedSerializedMap.set(computedAccessorOptions.propertyKey, true);
+              continue;
+            }
+            const isAllowed = await this.$evaluatePropertyAccess(ctx, app, propertyACLFilters);
+            if (isAllowed) {
+              allowedSerializedMap.set(computedAccessorOptions.propertyKey, true);
+            }
+          }
+          const relationshipOptions = this.$resourcefulRelationships.values();
+          for (const relationshipOption of relationshipOptions) {
+            const propertyACLFilters = relationshipOption.readAccessControlFilters;
+            if (!propertyACLFilters) {
+              allowedSerializedMap.set(relationshipOption.propertyKey, true);
+              continue;
+            }
+            const isAllowed = await this.$evaluatePropertyAccess(ctx, app, propertyACLFilters);
+            if (isAllowed) {
+              allowedSerializedMap.set(relationshipOption.propertyKey, true);
+            }
           }
         }
-        const hasNoAllowedFields = !allowedFieldsMap.size;
+        const hasNoAllowedFields = !allowedSerializedMap.size;
         if (hasNoAllowedFields) {
           return {
             isForbidden: true,
@@ -1330,7 +1718,7 @@ function withResourceful(options = {}) {
         }
         return {
           isForbidden: false,
-          allowedFieldsMap,
+          allowedSerializedMap,
           allowedColumnsMap
         };
       }
@@ -1343,6 +1731,40 @@ function withResourceful(options = {}) {
         });
         return ret;
       }
+      static $loadPossibilitiesForResourcefulRecord() {
+        const allRelationships = Array.from(this.$resourcefulRelationships.entries()).filter(([propertyKey]) => {
+          const relation = this.$getRelation(propertyKey);
+          return !relation ? false : true;
+        }).map(([propertyKey]) => propertyKey);
+        const possibleRelationships = Array.from(this.$resourcefulRelationships.entries()).filter(([propertyKey]) => {
+          const relation = this.$getRelation(propertyKey);
+          if (!relation) return false;
+          if (relation.serializeAs === null) return false;
+          return relation.type === "belongsTo" || relation.type === "hasOne";
+        }).map(([propertyKey]) => propertyKey);
+        const possibleColumns = Array.from(this.$resourcefulColumns.entries()).map(([propertyKey]) => propertyKey).filter((propertyKey) => {
+          const lucidColumnOptions = this.$getColumn(propertyKey);
+          if (!lucidColumnOptions) return false;
+          if (lucidColumnOptions.serializeAs === null) return false;
+          return lucidColumnOptions.serializeAs !== null;
+        });
+        const possibleComputed = Array.from(this.$resourcefulComputedAccessors.entries()).map(([propertyKey]) => propertyKey).filter((propertyKey) => {
+          const lucidComputedOptions = this.$getComputed(propertyKey);
+          if (!lucidComputedOptions) return false;
+          if (lucidComputedOptions.serializeAs === null) return false;
+          return lucidComputedOptions.serializeAs !== null;
+        });
+        const possibleFields = Array.from(
+          /* @__PURE__ */ new Set([...possibleColumns, ...possibleComputed, ...possibleRelationships])
+        ).map((prop) => this.$keys.attributesToSerialized.get(prop) || prop).filter((s) => "string" === typeof s);
+        return {
+          allRelationships,
+          possibleRelationships,
+          possibleColumns,
+          possibleComputed,
+          possibleFields
+        };
+      }
       /**
        * Performs paginated listing and searching of model records with comprehensive filtering.
        *
@@ -1402,22 +1824,33 @@ function withResourceful(options = {}) {
        * );
        * ```
        */
-      static $formatResourcefulRecord(record) {
+      static $formatResourcefulRecord(record, possibleFields) {
+        if (null === record || void 0 === record) {
+          return record;
+        }
         const result = {};
-        for (const [key, value] of Object.entries(record)) {
-          const serializable = this.$keys.columnsToSerialized.get(key);
-          const attribute = this.$keys.columnsToAttributes.get(key);
-          if (!attribute || !serializable) {
-            continue;
-          }
-          const opts = this.$getColumn(attribute);
-          if (!opts) {
-            continue;
+        const { possibleFields: allPossibleFields } = this.$loadPossibilitiesForResourcefulRecord();
+        possibleFields = possibleFields.filter((field) => allPossibleFields.includes(field));
+        possibleFields.forEach((field) => {
+          const attribute = this.$keys.serializedToAttributes.get(field) || field;
+          if (!attribute) return;
+          const value = record[attribute];
+          if (value !== void 0) {
+            const resourcefulRelationshipOptions = this.$resourcefulRelationships.get(attribute);
+            if (resourcefulRelationshipOptions) {
+              const relatedModel = resourcefulRelationshipOptions.relatedModel();
+              if ("function" === typeof relatedModel.$formatResourcefulRecord && "function" === typeof relatedModel.$loadPossibilitiesForResourcefulRecord) {
+                const { possibleFields: relatedPossibleFields } = relatedModel.$loadPossibilitiesForResourcefulRecord();
+                result[field] = relatedModel.$formatResourcefulRecord(value, relatedPossibleFields);
+              } else if ("function" === typeof value.serialize) {
+                result[field] = value.serialize();
+              }
+            } else {
+              result[field] = value;
+            }
           }
-          const preparedValue = decorator_utils.isFunction(opts.consume) ? opts.consume(value, attribute, this) : value;
-          result[serializable] = preparedValue;
-        }
-        return result;
+        });
+        return errors.stripUndefinedValuesFromObject(result);
       }
       static async $validatePayloadWithValidationGetters(ctx, app, payload, validationGetters) {
         const schemas = await Promise.all(validationGetters.map((getter) => getter(ctx, app)));
@@ -1449,19 +1882,22 @@ function withResourceful(options = {}) {
         if (!primaryKey) {
           throw new errors.E_MISSING_PRIMARY_KEY_EXCEPTION(this.$resourcefulName);
         }
-        if (!decorator_utils.isString(filter)) {
+        if (!errors.isString(filter)) {
           filter = "";
         }
-        fields = decorator_utils.prepareFields(fields, primaryKey);
-        const { isForbidden, allowedFieldsMap, message } = await this.$resourcefulCheckAccess({
+        fields = errors.prepareFields(fields, primaryKey);
+        const { isForbidden, allowedSerializedMap, message } = await this.$resourcefulCheckAccess({
           ctx,
           app,
-          operation: decorator_utils.CRUDOperationsEnum.LIST
+          operation: errors.CRUDOperationsEnum.LIST
         });
         if (isForbidden) {
           throw new errors.E_FORBIDDEN(message);
         }
-        const possibleFields = Array.from(allowedFieldsMap.keys());
+        const { allRelationships, possibleRelationships, possibleColumns, possibleComputed } = this.$loadPossibilitiesForResourcefulRecord();
+        const possibleFields = Array.from(allowedSerializedMap.keys()).filter(
+          (f) => possibleColumns.includes(f) || possibleComputed.includes(f) || !allRelationships.includes(f) || possibleRelationships.includes(f)
+        );
         if (possibleFields.length === 0) {
           throw new errors.E_INVALID_COLUMN_ACCESS("No fields available for access");
         }
@@ -1491,7 +1927,8 @@ function withResourceful(options = {}) {
           this.$keys.serializedToColumns,
           primaryKey,
           this.table,
-          possibleFields
+          possibleFields,
+          this
         );
         for (const scopeCallback of [
           ...this.$resourcefulQueryScopeCallbacks.list || [],
@@ -1499,28 +1936,47 @@ function withResourceful(options = {}) {
         ]) {
           await scopeCallback(ctx, app, query);
         }
-        const columnsToSelect = validatedMethodOptions.fields.filter((field) => allowedFieldsMap.has(field)).map((field) => this.$keys.serializedToColumns.get(field));
         const countQuery = query.clone();
         const recordsQuery = query.clone();
+        const privateKeyColumn = this.$keys.attributesToColumns.get(primaryKey);
         countQuery.count("*", "total");
-        recordsQuery.select(columnsToSelect).forPage(validatedMethodOptions.page, validatedMethodOptions.perPage);
+        recordsQuery.select(privateKeyColumn).forPage(validatedMethodOptions.page, validatedMethodOptions.perPage);
         if (Array.isArray(sort) && sort.length > 0) {
           sort.forEach(([field, direction]) => {
-            if (allowedFieldsMap.has(field)) {
-              recordsQuery.orderBy(field, direction);
+            const columnName = this.$keys.serializedToColumns.get(field);
+            if (allowedSerializedMap.has(field) && columnName) {
+              recordsQuery.orderBy(columnName, direction);
             }
           });
         }
         const countQueryQuery = countQuery.toQuery();
         const recordsQueryQuery = recordsQuery.toQuery();
-        const [countResults, rawRecords] = await Promise.all([countQuery, recordsQuery]);
+        const [countResults, rawRecordIds] = await Promise.all([countQuery, recordsQuery]);
         const totalRaw = Number((_a2 = countResults == null ? void 0 : countResults[0]) == null ? void 0 : _a2.total);
+        const rawRecordsUnsortedQuery = this.query().whereIn(
+          privateKeyColumn,
+          rawRecordIds.map((r) => r[privateKeyColumn])
+        );
+        const relationsToSelect = validatedMethodOptions.fields.filter(
+          (field) => allowedSerializedMap.has(field) && possibleRelationships.includes(field)
+        );
+        relationsToSelect.forEach((prop) => {
+          rawRecordsUnsortedQuery.preload(prop);
+        });
+        const rawRecordsUnsorted = await rawRecordsUnsortedQuery;
+        const rawRecords = rawRecordsUnsorted.sort((a2, b) => {
+          const aId = a2.$getAttribute(primaryKey);
+          const bId = b.$getAttribute(primaryKey);
+          const rawRecordIdResultsIndexA = rawRecordIds.findIndex((r) => r[primaryKey] === aId);
+          const rawRecordIdResultsIndexB = rawRecordIds.findIndex((r) => r[primaryKey] === bId);
+          return rawRecordIdResultsIndexA - rawRecordIdResultsIndexB;
+        });
         return {
           total: Number.isNaN(totalRaw) ? 0 : totalRaw,
           page: validatedMethodOptions.page,
           perPage: validatedMethodOptions.perPage,
           records: rawRecords.map(
-            (record) => this.$formatResourcefulRecord(record)
+            (record) => this.$formatResourcefulRecord(record, possibleFields)
           ),
           countQuery: countQueryQuery,
           recordsQuery: recordsQueryQuery
@@ -1563,27 +2019,211 @@ function withResourceful(options = {}) {
           throw new errors.E_RECORD_NOT_FOUND_EXCEPTION();
         }
         const rid = recordRaw[this.primaryKey];
-        const record = await this.query().where(this.primaryKey, rid).first();
+        const recordQuery = this.query().where(this.primaryKey, rid);
+        const { possibleRelationships, possibleFields } = this.$loadPossibilitiesForResourcefulRecord();
+        possibleRelationships.forEach((prop) => {
+          recordQuery.preload(prop);
+        });
+        const record = await recordQuery.first();
         if (!record) {
           throw new errors.E_RECORD_NOT_FOUND_EXCEPTION();
         }
-        const { isForbidden, allowedFieldsMap, message } = await this.$resourcefulCheckAccess({
+        const { isForbidden, allowedSerializedMap, message } = await this.$resourcefulCheckAccess({
           ctx,
           app,
           instance: record,
-          operation: decorator_utils.CRUDOperationsEnum.READ
+          operation: errors.CRUDOperationsEnum.READ
         });
         if (isForbidden) {
           throw new errors.E_FORBIDDEN(message);
         }
-        const recordObject = record.toObject();
-        const recordObjectWithAllowedFields = {};
-        for (const [key, value] of Object.entries(recordObject)) {
-          if (allowedFieldsMap.has(key)) {
-            recordObjectWithAllowedFields[key] = value;
+        return this.$formatResourcefulRecord(
+          record,
+          possibleFields.filter((f) => allowedSerializedMap.get(f) === true)
+        );
+      }
+      /**
+       * Loads a specific relationship for a model record with pagination, filtering, and access control.
+       *
+       * This method provides paginated relationship loading by leveraging the related model's
+       * $onResourcefulIndex method with automatically generated relationship constraints.
+       * It supports full filtering, sorting, and pagination capabilities while maintaining
+       * proper access control and scoping.
+       *
+       * The method automatically generates query scope hooks to constrain results to only
+       * records related to the specified parent record, preventing unauthorized data access
+       * and ensuring proper relationship boundaries are maintained.
+       *
+       * @param uid - The unique identifier of the parent record
+       * @param relationshipKey - The name of the relationship property to load
+       * @param filter - Lucene-style query string for filtering related records
+       * @param page - The page number for pagination (must be ≥ 1)
+       * @param perPage - Number of records per page (must be ≥ 1 and ≤ 100)
+       * @param fields - Array of field names to include in the response from the related model
+       * @param sort - Array of sort criteria as [field, direction] tuples
+       * @param ctx - HTTP context containing request information and authentication
+       * @param app - Application service instance for accessing app-level services
+       * @param hooks - Optional array of additional query scope callbacks
+       *
+       * @returns Promise resolving to paginated relationship results with the same structure as $onResourcefulIndex
+       *
+       * @throws {E_MISSING_PRIMARY_KEY_EXCEPTION} When the model has no identifiable primary key
+       * @throws {E_INVALID_RELATIONSHIP_EXCEPTION} When the specified relationship doesn't exist or isn't resourceful
+       * @throws {E_FORBIDDEN} When access is denied by model-level or field-level ACL filters
+       * @throws {E_INVALID_RESOUREFUL_INDEX_REQUEST_EXCEPTION} When input validation fails
+       *
+       * @example
+       * ```typescript
+       * // Load user's posts with filtering and pagination
+       * const userPosts = await Post.$onResourcefulReadRelationship(
+       *   123,                    // user ID
+       *   'posts',               // relationship name
+       *   'status:published',    // filter
+       *   1,                     // page
+       *   10,                    // perPage
+       *   ['id', 'title'],       // fields
+       *   [['createdAt', 'desc']], // sort
+       *   ctx,
+       *   app
+       * );
+       *
+       * // Load user's skills (many-to-many)
+       * const userSkills = await Skill.$onResourcefulReadRelationship(
+       *   123,
+       *   'skills',
+       *   null,  // no filter
+       *   1,
+       *   50,
+       *   null,  // all fields
+       *   null,  // default sort
+       *   ctx,
+       *   app
+       * );
+       * ```
+       */
+      static async $onResourcefulReadRelationship(uid, relationshipKey, filter, page, perPage, fields, sort, ctx, app, hooks = []) {
+        const primaryKey = this.$getPrivateKeyAttribute();
+        if (!primaryKey) {
+          throw new errors.E_MISSING_PRIMARY_KEY_EXCEPTION(this.$resourcefulName);
+        }
+        const relationshipDefinition = this.$resourcefulRelationships.get(relationshipKey);
+        if (!relationshipDefinition) {
+          throw new errors.E_INVALID_RELATIONSHIP_EXCEPTION(
+            `Relationship '${relationshipKey}' not found on model '${this.$resourcefulName}'`
+          );
+        }
+        const lucidRelationshipDefinition = this.$getRelation(relationshipKey);
+        if (!lucidRelationshipDefinition) {
+          throw new errors.E_INVALID_RELATIONSHIP_EXCEPTION(
+            `Lucid relationship '${relationshipKey}' not found on model '${this.$resourcefulName}'`
+          );
+        }
+        const RelatedModel = relationshipDefinition.relatedModel();
+        if (typeof RelatedModel.$onResourcefulIndex !== "function") {
+          throw new errors.E_INVALID_RELATIONSHIP_EXCEPTION(
+            `Related model for '${relationshipKey}' does not implement resourceful operations`
+          );
+        }
+        const relationshipHook = async (_hookCtx, _hookApp, query) => {
+          const relationshipType = lucidRelationshipDefinition.type;
+          switch (relationshipType) {
+            case "hasMany":
+              {
+                const foreignKey = lucidRelationshipDefinition.foreignKey;
+                if (!foreignKey) {
+                  throw new errors.E_INVALID_RELATIONSHIP_EXCEPTION(
+                    `HasMany relationship '${relationshipKey}' missing foreignKey`
+                  );
+                }
+                const foreignColumn = RelatedModel.$keys.attributesToColumns.get(foreignKey);
+                if (!foreignColumn) {
+                  throw new errors.E_INVALID_RELATIONSHIP_EXCEPTION(
+                    `Foreign key '${foreignKey}' not found in related model columns`
+                  );
+                }
+                query.where(foreignColumn, uid);
+              }
+              break;
+            case "manyToMany":
+              {
+                const pivotTable = lucidRelationshipDefinition.pivotTable;
+                const localKey = lucidRelationshipDefinition.localKey;
+                const relatedKey = lucidRelationshipDefinition.relatedKey;
+                const pivotForeignKey = lucidRelationshipDefinition.pivotForeignKey;
+                const pivotRelatedForeignKey = lucidRelationshipDefinition.pivotRelatedForeignKey;
+                if (!pivotTable || !localKey || !relatedKey || !pivotForeignKey || !pivotRelatedForeignKey) {
+                  throw new errors.E_INVALID_RELATIONSHIP_EXCEPTION(
+                    `ManyToMany relationship '${relationshipKey}' missing required pivot configuration`
+                  );
+                }
+                const relatedColumn = RelatedModel.$keys.attributesToColumns.get(relatedKey);
+                if (!relatedColumn) {
+                  throw new errors.E_INVALID_RELATIONSHIP_EXCEPTION(
+                    `Related key '${relatedKey}' not found in related model columns`
+                  );
+                }
+                query.whereExists((subQuery) => {
+                  subQuery.from(pivotTable).select(1).whereColumn(
+                    `${pivotTable}.${pivotRelatedForeignKey}`,
+                    `${RelatedModel.table}.${relatedColumn}`
+                  ).where(`${pivotTable}.${pivotForeignKey}`, uid);
+                });
+              }
+              break;
+            case "hasManyThrough":
+              {
+                const throughModel = lucidRelationshipDefinition.options.throughModel ? lucidRelationshipDefinition.options.throughModel() : void 0;
+                const foreignKey = lucidRelationshipDefinition.options.foreignKey || RelatedModel.primaryKey;
+                const localKey = lucidRelationshipDefinition.options.localKey || this.primaryKey;
+                const throughForeignKey = lucidRelationshipDefinition.options.throughForeignKey;
+                const throughLocalKey = lucidRelationshipDefinition.options.throughLocalKey || (throughModel == null ? void 0 : throughModel.primaryKey);
+                if (!throughModel || !foreignKey || !localKey || !throughForeignKey || !throughLocalKey) {
+                  throw new errors.E_INVALID_RELATIONSHIP_EXCEPTION(
+                    `HasManyThrough relationship '${relationshipKey}' missing required through configuration`
+                  );
+                }
+                const foreignColumn = RelatedModel.$keys.attributesToColumns.get(foreignKey);
+                const localColumn = this.$keys.attributesToColumns.get(localKey);
+                const throughForeignColumn = RelatedModel.$keys.attributesToColumns.get(throughForeignKey);
+                const throughLocalColumn = throughModel.$keys.attributesToColumns.get(throughLocalKey);
+                if (!throughLocalColumn || !throughForeignColumn || !foreignColumn || !localColumn) {
+                  throw new errors.E_INVALID_RELATIONSHIP_EXCEPTION(
+                    `HasManyThrough relationship '${relationshipKey}' has invalid key mappings`
+                  );
+                }
+                query.whereExists((subQuery) => {
+                  subQuery.from(throughModel.table).select(1).where(`${throughModel.table}.${throughLocalColumn}`, uid).whereColumn(
+                    `${throughModel.table}.${foreignColumn}`,
+                    `${RelatedModel.table}.${throughForeignColumn}`
+                  ).limit(1);
+                });
+              }
+              break;
+            default:
+              throw new errors.E_INVALID_RELATIONSHIP_EXCEPTION(
+                `Relationship type '${relationshipType}' is not supported for paginated loading`
+              );
+          }
+        };
+        const allHooks = [relationshipHook, ...hooks];
+        try {
+          return RelatedModel.$onResourcefulIndex(
+            filter,
+            page,
+            perPage,
+            fields,
+            sort,
+            ctx,
+            app,
+            allHooks
+          );
+        } catch (err) {
+          if (err instanceof errors.E_INVALID_RESOUREFUL_INDEX_REQUEST_EXCEPTION) {
+            throw new errors.E_INVALID_RESOUREFUL_READ_RELATIONSHIP_REQUEST_EXCEPTION(err);
+          } else {
+            throw err;
           }
         }
-        return recordObjectWithAllowedFields;
       }
       /**
        * Creates a new model record with payload validation and access control.
@@ -1624,23 +2264,31 @@ function withResourceful(options = {}) {
             throw new errors.E_FORBIDDEN_PAYLOAD_EXCEPTION(payloadSchemaGettersError);
           }
         }
-        const { isForbidden, allowedFieldsMap, message } = await this.$resourcefulCheckAccess({
+        const { isForbidden, allowedSerializedMap, message } = await this.$resourcefulCheckAccess({
           ctx,
           app,
-          operation: decorator_utils.CRUDOperationsEnum.CREATE
+          operation: errors.CRUDOperationsEnum.CREATE
         });
         if (isForbidden) {
           throw new errors.E_FORBIDDEN(message);
         }
         const preparedPayload = {};
         for (const [key, value] of Object.entries(payload)) {
-          const attribute = this.$keys.serializedToAttributes.get(key);
+          let attribute = this.$keys.serializedToAttributes.get(key);
           const isValueNull = value === null || value === void 0;
           if (!attribute) {
-            continue;
+            const columnExists = typeof this.$keys.attributesToColumns.get(key) !== "undefined";
+            if (columnExists) {
+              attribute = key;
+            } else {
+              continue;
+            }
           }
-          if (!isValueNull && !allowedFieldsMap.has(attribute)) {
-            throw new errors.E_FORBIDDEN(`User does not has write access to field ${attribute}.`);
+          const isAllowedBySerializedName = allowedSerializedMap.has(key);
+          const isAllowedByColumnName = allowedSerializedMap.has(attribute);
+          const isAllowed = isAllowedBySerializedName || isAllowedByColumnName;
+          if (!isValueNull && !isAllowed) {
+            throw new errors.E_FORBIDDEN(`User does not has write access to field ${key}.`);
           }
           preparedPayload[attribute] = value;
         }
@@ -1700,23 +2348,31 @@ function withResourceful(options = {}) {
         if (!record) {
           throw new errors.E_RECORD_NOT_FOUND_EXCEPTION();
         }
-        const { isForbidden, allowedFieldsMap, message } = await this.$resourcefulCheckAccess({
+        const { isForbidden, allowedSerializedMap, message } = await this.$resourcefulCheckAccess({
           ctx,
           app,
           instance: record,
-          operation: decorator_utils.CRUDOperationsEnum.UPDATE
+          operation: errors.CRUDOperationsEnum.UPDATE
         });
         if (isForbidden) {
           throw new errors.E_FORBIDDEN(message);
         }
         const preparedPayload = {};
-        for (const [key, value] of Object.entries(payload)) {
-          const attribute = this.$keys.serializedToAttributes.get(key);
+        for (const [serializedKey, value] of Object.entries(payload)) {
+          let attribute = this.$keys.serializedToAttributes.get(serializedKey);
           const isValueNull = value === null || value === void 0;
           if (!attribute) {
-            continue;
+            const columnExists = typeof this.$keys.attributesToColumns.get(serializedKey) !== "undefined";
+            if (columnExists) {
+              attribute = serializedKey;
+            } else {
+              continue;
+            }
           }
-          if (!isValueNull && !allowedFieldsMap.has(attribute)) {
+          const isAllowedBySerializedName = allowedSerializedMap.has(serializedKey);
+          const isAllowedByColumnName = allowedSerializedMap.has(attribute);
+          const isAllowed = isAllowedBySerializedName || isAllowedByColumnName;
+          if (!isValueNull && !isAllowed) {
             throw new errors.E_FORBIDDEN(`User does not has write access to field ${attribute}.`);
           }
           preparedPayload[attribute] = value;
@@ -1762,18 +2418,88 @@ function withResourceful(options = {}) {
         if (!rawRecord) {
           throw new errors.E_RECORD_NOT_FOUND_EXCEPTION();
         }
-        const record = new this().merge(this.$formatResourcefulRecord(rawRecord));
+        const { possibleFields } = this.$loadPossibilitiesForResourcefulRecord();
+        const record = new this().merge(this.$formatResourcefulRecord(rawRecord, possibleFields));
         const { isForbidden, message } = await this.$resourcefulCheckAccess({
           ctx,
           app,
           instance: record,
-          operation: decorator_utils.CRUDOperationsEnum.DELETE
+          operation: errors.CRUDOperationsEnum.DELETE
         });
         if (isForbidden) {
           throw new errors.E_FORBIDDEN(message);
         }
         await record.delete();
       }
+      static async $onResourcefulBulkUpdate(filter, payload, ctx, app, hooks = {}) {
+        const primaryKey = this.$getPrivateKeyAttribute();
+        if (!primaryKey) {
+          throw new errors.E_MISSING_PRIMARY_KEY_EXCEPTION(this.$resourcefulName);
+        }
+        const ctor = this;
+        async function* resourcefulIndexIteratorForUpdate(f) {
+          let page = 1;
+          let pages = 0;
+          const pk = ctor.$getPrivateKeyAttribute();
+          if (!pk) return;
+          const whileAbortController = new AbortController();
+          while ((pages === 0 || page <= pages) && whileAbortController.signal.aborted === false) {
+            try {
+              const result = await ctor.$onResourcefulIndex(
+                f,
+                page,
+                100,
+                [pk],
+                [[pk, "asc"]],
+                ctx,
+                app,
+                hooks.queryScopeCallbacks || []
+              );
+              if (result.total === 0) {
+                whileAbortController.abort();
+                break;
+              }
+              pages = Math.ceil(result.total / result.perPage);
+              page++;
+              yield result.records;
+            } catch (err) {
+              whileAbortController.abort();
+              if (err instanceof Error) {
+                throw err;
+              } else {
+                throw new errors.E_BULK_UPDATE_SEARCH_UNKNOWN_EXCEPTION();
+              }
+            }
+          }
+        }
+        const uids = /* @__PURE__ */ new Set();
+        for await (const records of resourcefulIndexIteratorForUpdate(filter)) {
+          for (const record of records) {
+            const uid = record[primaryKey];
+            if (uid !== void 0 && uid !== null) {
+              uids.add(uid);
+            }
+          }
+        }
+        return await this.$onResourcefulBulkUpdateByUid(Array.from(uids), payload, ctx, app, hooks);
+      }
+      static async $onResourcefulBulkUpdateByUid(uids, payload, ctx, app, hooks, concurrency = 5) {
+        const results = {};
+        /* istanbul ignore next -- @preserve */
+        await pMap(
+          uids,
+          async (uid) => {
+            try {
+              results[uid] = await this.$onResourcefulUpdate(uid, payload, ctx, app, hooks);
+            } catch (err) {
+              const e = err instanceof Error ? err : new Error("Unknown error during update");
+              results[uid] = e;
+            }
+          },
+          { concurrency }
+        );
+        return results;
+      }
     }
     __publicField(ResourcefulModel, "$resourcefulColumns", resourcefulColumns);
     __publicField(ResourcefulModel, "$resourcefulRelationships", resourcefulRelationships);
@@ -11857,10 +12583,12 @@ const resourcefulColumnOptionsSchema = joi.joi.object({
   type: resourcefulDataTypeSchema.required()
 });
 const dataTypeColumnOptionsSchema = joi.joi.object({
-  // Lucid ColumnOptions (partial) - excluding 'prepare' and 'consume'
+  // Lucid ColumnOptions (full) - now including 'prepare' and 'consume'
   columnName: joi.joi.string().optional(),
   serializeAs: joi.joi.alternatives().try(joi.joi.string(), joi.joi.valid(null)).optional(),
   serialize: joi.joi.function().optional(),
+  consume: joi.joi.function().optional(),
+  prepare: joi.joi.function().optional(),
   meta: joi.joi.object().optional(),
   isPrimary: joi.joi.boolean().default(false),
   hasDefaultValue: joi.joi.boolean().default(false),
@@ -12723,7 +13451,7 @@ function resourcefulHasManyThrough(model, options = {}) {
     map.set(propertyKey, opts);
   };
 }
-const version = "0.1.0-master-71781cfd";
+const version = "0.1.0-master-3ec631a4";
 exports.errors = errors.errors;
 exports.definitions = definitions.definitions;
 exports.resourcefulBelongsTo = resourcefulBelongsTo;