nicot 1.1.37 → 1.2.0

package/dist/index.cjs

@@ -40,7 +40,6 @@ var index_exports = {};
 __export(index_exports, {
   BlankCursorPaginationReturnMessageDto: () => BlankCursorPaginationReturnMessageDto,
   BoolColumn: () => BoolColumn,
-  CreatePipe: () => CreatePipe,
   CrudBase: () => CrudBase,
   CrudService: () => CrudService,
   CursorPaginationDto: () => CursorPaginationDto,
@@ -49,7 +48,14 @@ __export(index_exports, {
   EnumColumn: () => EnumColumn,
   FloatColumn: () => FloatColumn,
   GenericCursorPaginationReturnMessageDto: () => GenericCursorPaginationReturnMessageDto,
-  GetPipe: () => GetPipe,
+  GetMutator: () => GetMutator,
+  GetMutatorBool: () => GetMutatorBool,
+  GetMutatorFloat: () => GetMutatorFloat,
+  GetMutatorFloatSeparated: () => GetMutatorFloatSeparated,
+  GetMutatorInt: () => GetMutatorInt,
+  GetMutatorIntSeparated: () => GetMutatorIntSeparated,
+  GetMutatorJson: () => GetMutatorJson,
+  GetMutatorStringSeparated: () => GetMutatorStringSeparated,
   IdBase: () => IdBase,
   ImportDataBaseDto: () => ImportDataBaseDto,
   ImportDataDto: () => ImportDataDto,
@@ -60,10 +66,15 @@ __export(index_exports, {
   JsonColumn: () => JsonColumn,
   NotChangeable: () => NotChangeable,
   NotColumn: () => NotColumn,
+  NotCreatable: () => NotCreatable,
   NotInResult: () => NotInResult,
   NotQueryable: () => NotQueryable,
   NotWritable: () => NotWritable,
+  OmitPipe: () => OmitPipe,
+  OptionalDataPipe: () => OptionalDataPipe,
   PageSettingsDto: () => PageSettingsDto,
+  PickPipe: () => PickPipe,
+  QueryAnd: () => QueryAnd,
   QueryColumn: () => QueryColumn,
   QueryCondition: () => QueryCondition,
   QueryEqual: () => QueryEqual,
@@ -71,16 +82,24 @@ __export(index_exports, {
   QueryFullText: () => QueryFullText,
   QueryGreater: () => QueryGreater,
   QueryGreaterEqual: () => QueryGreaterEqual,
+  QueryIn: () => QueryIn,
+  QueryJsonbHas: () => QueryJsonbHas,
   QueryLess: () => QueryLess,
   QueryLessEqual: () => QueryLessEqual,
   QueryLike: () => QueryLike,
+  QueryManual: () => QueryManual,
   QueryMatchBoolean: () => QueryMatchBoolean,
   QueryMatchBooleanMySQL: () => QueryMatchBooleanMySQL,
   QueryNotEqual: () => QueryNotEqual,
+  QueryNotIn: () => QueryNotIn,
   QueryOperator: () => QueryOperator,
+  QueryOr: () => QueryOr,
   QuerySearch: () => QuerySearch,
+  QueryWrap: () => QueryWrap,
+  QueryWrapInfo: () => QueryWrapInfo,
   Relation: () => Relation,
   RelationComputed: () => RelationComputed,
+  RequireGetMutator: () => RequireGetMutator,
   RestfulFactory: () => RestfulFactory,
   SimpleJsonColumn: () => SimpleJsonColumn,
   StringColumn: () => StringColumn,
@@ -88,7 +107,6 @@ __export(index_exports, {
   StringJsonColumn: () => StringJsonColumn,
   TextColumn: () => TextColumn,
   TimeBase: () => TimeBase,
-  UpdatePipe: () => UpdatePipe,
   UuidColumn: () => UuidColumn,
   applyQueryMatchBoolean: () => applyQueryMatchBoolean,
   applyQueryMatchBooleanMySQL: () => applyQueryMatchBooleanMySQL,
@@ -96,8 +114,12 @@ __export(index_exports, {
   applyQueryPropertyLike: () => applyQueryPropertyLike,
   applyQueryPropertySearch: () => applyQueryPropertySearch,
   applyQueryPropertyZeroNullable: () => applyQueryPropertyZeroNullable,
+  createGetMutator: () => createGetMutator,
+  createQueryArrayify: () => createQueryArrayify,
   createQueryCondition: () => createQueryCondition,
-  createQueryOperator: () => createQueryOperator
+  createQueryOperator: () => createQueryOperator,
+  createQueryOperatorArrayify: () => createQueryOperatorArrayify,
+  createQueryWrap: () => createQueryWrap
 });
 module.exports = __toCommonJS(index_exports);
 __reExport(index_exports, require("nesties"), module.exports);
@@ -144,7 +166,6 @@ var import_swagger3 = require("@nestjs/swagger");
 var import_nesties6 = require("nesties");
 
 // src/decorators/access.ts
-var import_class_transformer2 = require("class-transformer");
 var import_class_validator2 = require("class-validator");
 
 // src/utility/metadata.ts
@@ -171,13 +192,14 @@ function getNotInResultFields(obj, keepEntityVersioningDates = false) {
 // src/decorators/access.ts
 var import_nesties2 = require("nesties");
 var NotWritable = () => (0, import_nesties2.MergePropertyDecorators)([
-  (0, import_class_transformer2.Expose)({ groups: ["r"] }),
   (0, import_class_validator2.IsOptional)(),
-  Metadata.set("notWritable", true, "notWritableFields"),
-  Metadata.set("notChangeable", true, "notChangeableFields")
+  Metadata.set("notWritable", true, "notWritableFields")
+]);
+var NotCreatable = () => (0, import_nesties2.MergePropertyDecorators)([
+  (0, import_class_validator2.IsOptional)(),
+  Metadata.set("notCreatable", true, "notCreatableFields")
 ]);
 var NotChangeable = () => (0, import_nesties2.MergePropertyDecorators)([
-  (0, import_class_transformer2.Expose)({ groups: ["r", "c"] }),
   Metadata.set("notChangeable", true, "notChangeableFields")
 ]);
 var NotQueryable = () => Metadata.set("notQueryable", true, "notQueryableFields");
@@ -188,7 +210,7 @@ var import_swagger2 = require("@nestjs/swagger");
 var import_nesties3 = require("nesties");
 var import_typeorm = require("typeorm");
 var import_class_validator3 = require("class-validator");
-var import_class_transformer3 = require("class-transformer");
+var import_class_transformer2 = require("class-transformer");
 
 // src/utility/bigint.ts
 var BigintTransformer = class {
@@ -304,21 +326,45 @@ var parseBool = (value) => {
   }
   return void 0;
 };
-var parseBoolObject = (obj, boolFields) => {
-  const newObj = { ...obj };
-  for (const field of boolFields) {
-    newObj[field] = parseBool(newObj[field]);
+
+// src/decorators/get-mutator.ts
+var RequireGetMutator = () => Metadata.set("requireGetMutator", true, "requireGetMutatorFields");
+var GetMutator = (mutator, options = {}) => Metadata.set("getMutator", { mutator, ...options }, "getMutatorFields");
+var createGetMutator = (mutator, defaultOptions = {}) => (options = {}) => GetMutator(mutator, {
+  ...defaultOptions,
+  ...options,
+  apiPropertyExtras: {
+    ...defaultOptions.apiPropertyExtras || {},
+    ...options.apiPropertyExtras || {}
   }
-  return newObj;
-};
-var ParseBoolObjectPipe = class {
-  constructor(boolFields) {
-    this.boolFields = boolFields;
+});
+var GetMutatorBool = createGetMutator(parseBool, {
+  enum: ["0", "1"],
+  example: "1"
+});
+var GetMutatorInt = createGetMutator((s) => parseInt(s, 10));
+var GetMutatorFloat = createGetMutator((s) => parseFloat(s));
+var GetMutatorStringSeparated = (separator = ",", options = {}) => GetMutator((s) => s.split(separator), {
+  example: `value1${separator}value2${separator}value3`,
+  ...options
+});
+var GetMutatorIntSeparated = (separator = ",", options = {}) => GetMutator(
+  (s) => s.split(separator).map((item) => parseInt(item.trim(), 10)),
+  {
+    example: `1${separator}2${separator}3`,
+    ...options
   }
-  transform(obj) {
-    return parseBoolObject(obj, this.boolFields);
+);
+var GetMutatorFloatSeparated = (separator = ",", options = {}) => GetMutator(
+  (s) => s.split(separator).map((item) => parseFloat(item.trim())),
+  {
+    example: `1.5${separator}2.5${separator}3.5`,
+    ...options
   }
-};
+);
+var GetMutatorJson = createGetMutator((s) => JSON.parse(s), {
+  example: `{"key1":"value1","key2":2,"key3":[1,2,3]}`
+});
 
 // src/decorators/property.ts
 var NotRequiredButHasDefaultDec = () => Metadata.set(
@@ -476,7 +522,7 @@ var DateColumn = (options = {}) => {
       columnDecoratorOptions(options)
     ),
     (0, import_class_validator3.IsDate)(),
-    (0, import_class_transformer3.Transform)(
+    (0, import_class_transformer2.Transform)(
       (v) => {
         const value = v.value;
         if (value == null || value instanceof Date) return value;
@@ -513,19 +559,19 @@ var EnumColumn = (targetEnum, options = {}) => {
 };
 var BoolColumn = (options = {}) => (0, import_nesties3.MergePropertyDecorators)([
   (0, import_typeorm.Index)(),
-  (0, import_class_transformer3.Transform)((v) => {
+  (0, import_class_transformer2.Transform)((v) => {
     return parseBool(v.value);
   }),
   (0, import_typeorm.Column)("boolean", columnDecoratorOptions(options)),
   validatorDecorator(options),
   swaggerDecorator(options, { type: Boolean }),
-  Metadata.set("boolColumn", true, "boolColumnFields")
+  GetMutatorBool()
 ]);
 var createJsonColumnDef = (columnType = "jsonb", typeTransformerClass = TypeTransformer) => (definition, options = {}) => {
   const cl = (0, import_nesties4.getClassFromClassOrArray)(definition);
   return (0, import_nesties3.MergePropertyDecorators)([
-    NotQueryable(),
-    (0, import_class_transformer3.Type)(() => cl),
+    RequireGetMutator(),
+    (0, import_class_transformer2.Type)(() => cl),
     (0, import_class_validator3.ValidateNested)(),
     (0, import_typeorm.Column)(options.columnType || columnType, {
       ...columnDecoratorOptions(options),
@@ -542,7 +588,7 @@ var StringJsonColumn = createJsonColumnDef(
   TypeTransformerString
 );
 var NotColumn = (options = {}, specials = {}) => (0, import_nesties3.MergePropertyDecorators)([
-  (0, import_class_transformer3.Exclude)(),
+  (0, import_class_transformer2.Exclude)(),
   swaggerDecorator({
     required: false,
     ...options
@@ -572,89 +618,48 @@ var RelationComputed = (type) => (obj, propertyKey) => {
 
 // src/decorators/pipes.ts
 var import_common = require("@nestjs/common");
-var CreatePipe = () => new import_common.ValidationPipe({
-  transform: true,
-  transformOptions: { groups: ["c"], enableImplicitConversion: true }
-});
-var GetPipe = () => new import_common.ValidationPipe({
+var OptionalDataPipe = () => new import_common.ValidationPipe({
   transform: true,
-  transformOptions: { groups: ["r"], enableImplicitConversion: true },
+  transformOptions: { enableImplicitConversion: true },
   skipMissingProperties: true,
   skipNullProperties: true,
   skipUndefinedProperties: true
 });
-var UpdatePipe = () => new import_common.ValidationPipe({
-  transform: true,
-  transformOptions: { groups: ["u"], enableImplicitConversion: true },
-  skipMissingProperties: true,
-  skipNullProperties: true,
-  skipUndefinedProperties: true
-});
-
-// src/utility/query.ts
-function createQueryCondition(cond) {
-  return (obj, qb, entityName, ...fields) => {
-    for (const field of fields) {
-      if (obj[field] == null) {
-        continue;
-      }
-      const ret = cond(obj, qb, entityName, field);
-      if (typeof ret === "string") {
-        qb.andWhere(ret);
-      } else if (typeof ret === "object" && typeof ret["query"] === "string") {
-        const _ret = ret;
-        qb.andWhere(_ret.query, _ret.params);
-      }
-    }
-    return qb;
-  };
-}
-var applyQueryProperty = createQueryCondition(
-  (obj, qb, entityName, field) => qb.andWhere(`${entityName}.${field} = :${field}`, { [field]: obj[field] })
-);
-var applyQueryPropertyLike = createQueryCondition(
-  (obj, qb, entityName, field) => qb.andWhere(`${entityName}.${field} like (:${field} || '%')`, {
-    [field]: obj[field]
-  })
-);
-var applyQueryPropertySearch = createQueryCondition(
-  (obj, qb, entityName, field) => qb.andWhere(`${entityName}.${field} like ('%' || :${field} || '%')`, {
-    [field]: obj[field]
-  })
-);
-var applyQueryPropertyZeroNullable = createQueryCondition(
-  (obj, qb, entityName, field) => {
-    if ([0, "0"].indexOf(obj[field]) !== -1) {
-      qb.andWhere(`${entityName}.${field} IS NULL`);
-    } else {
-      qb.andWhere(`${entityName}.${field} = :${field}`, {
-        [field]: obj[field]
-      });
-    }
-  }
-);
-var applyQueryMatchBoolean = createQueryCondition(
-  (obj, qb, entityName, field) => {
-    const value = parseBool(obj[field]);
-    if (value === true) {
-      qb.andWhere(`${entityName}.${field} = TRUE`);
+var PickPipe = (fields) => ({
+  transform(obj) {
+    if (obj === null || typeof obj !== "object") {
+      return obj;
     }
-    if (value === false) {
-      qb.andWhere(`${entityName}.${field} = FALSE`);
+    const proto = Object.getPrototypeOf(obj);
+    const clone = Object.create(proto);
+    const fieldSet = new Set(fields);
+    for (const key of fieldSet) {
+      const desc = Object.getOwnPropertyDescriptor(obj, key);
+      if (desc) {
+        Object.defineProperty(clone, key, desc);
+      }
     }
+    return clone;
   }
-);
-var applyQueryMatchBooleanMySQL = createQueryCondition(
-  (obj, qb, entityName, field) => {
-    const value = parseBool(obj[field]);
-    if (value === true) {
-      qb.andWhere(`${entityName}.${field} = 1`);
+});
+var OmitPipe = (fields) => ({
+  transform(obj) {
+    if (obj === null || typeof obj !== "object") {
+      return obj;
     }
-    if (value === false) {
-      qb.andWhere(`${entityName}.${field} = 0`);
+    const proto = Object.getPrototypeOf(obj);
+    const clone = Object.create(proto);
+    const omitSet = new Set(fields);
+    for (const key of Reflect.ownKeys(obj)) {
+      if (omitSet.has(key)) continue;
+      const desc = Object.getOwnPropertyDescriptor(obj, key);
+      if (desc) {
+        Object.defineProperty(clone, key, desc);
+      }
     }
+    return clone;
   }
-);
+});
 
 // src/decorators/query.ts
 var import_nesties5 = require("nesties");
@@ -689,31 +694,118 @@ var getSubject = (qb, alias) => {
 };
 
 // src/decorators/query.ts
+var import_typeorm2 = require("typeorm");
 var QueryCondition = (cond) => Metadata.set(
   "queryCondition",
   cond,
   "queryConditionFields"
 );
-var QueryEqual = () => QueryCondition(applyQueryProperty);
-var QueryLike = () => QueryCondition(applyQueryPropertyLike);
-var QuerySearch = () => QueryCondition(applyQueryPropertySearch);
-var QueryEqualZeroNullable = () => QueryCondition(applyQueryPropertyZeroNullable);
-var QueryMatchBoolean = () => QueryCondition(applyQueryMatchBoolean);
-var QueryMatchBooleanMySQL = () => QueryCondition(applyQueryMatchBooleanMySQL);
-var QueryOperator = (operator, field) => QueryCondition((obj, qb, entityName, key) => {
+var QueryManual = () => QueryCondition((obj, qb, entityName, key) => {
+});
+var QueryWrapInfo = class {
+  constructor(obj, key, field) {
+    this.obj = obj;
+    this.key = key;
+    this.field = field;
+    this._value = obj[key];
+  }
+  get value() {
+    return this._value;
+  }
+  mutateValue(next) {
+    this._value = next;
+  }
+};
+var queryWrapCounters = /* @__PURE__ */ new WeakMap();
+var getQueryVarName = (obj, key) => {
+  const queryCounters = queryWrapCounters.get(obj) || {};
+  let useField = `_qw_` + key;
+  if (queryCounters[key] == null) {
+    queryCounters[key] = 0;
+  } else {
+    useField += `__${queryCounters[key].toString(36)}`;
+    ++queryCounters[key];
+  }
+  queryWrapCounters.set(obj, queryCounters);
+  return useField;
+};
+var QueryWrap = (wrapper, field) => QueryCondition((obj, qb, entityName, key) => {
   if (obj[key] == null) return;
   const fieldName = field || key;
-  const typeormField = `_query_operator_${entityName}_${fieldName}_${key}`;
-  qb.andWhere(`${entityName}.${fieldName} ${operator} :${typeormField}`, {
-    [typeormField]: obj[key]
-  });
+  const varField = getQueryVarName(obj, key);
+  const entityExpr = `${entityName}.${fieldName}`;
+  const varExpr = `:${varField}`;
+  const info = new QueryWrapInfo(obj, key, fieldName);
+  const expr = wrapper(entityExpr, varExpr, info);
+  if (expr) {
+    qb.andWhere(expr, {
+      [varField]: info.value
+    });
+  }
 });
+var createQueryWrap = (wrapper) => (field) => QueryWrap(wrapper, field);
+var QueryLike = createQueryWrap(
+  (entityExpr, varExpr) => `${entityExpr} LIKE (${varExpr} || '%')`
+);
+var QuerySearch = createQueryWrap(
+  (entityExpr, varExpr) => `${entityExpr} LIKE ('%' || ${varExpr} || '%')`
+);
+var QueryEqualZeroNullable = createQueryWrap(
+  (entityExpr, varExpr, info) => [0, "0"].indexOf(info.value) !== -1 ? `${entityExpr} IS NULL` : `${entityExpr} = ${varExpr}`
+);
+var QueryMatchBoolean = createQueryWrap(
+  (entityExpr, varExpr, info) => {
+    const value = parseBool(info.value);
+    if (value === true) {
+      return `${entityExpr} = TRUE`;
+    }
+    if (value === false) {
+      return `${entityExpr} = FALSE`;
+    }
+  }
+);
+var QueryMatchBooleanMySQL = createQueryWrap(
+  (entityExpr, varExpr, info) => {
+    const value = parseBool(info.value);
+    if (value === true) {
+      return `${entityExpr} = 1`;
+    }
+    if (value === false) {
+      return `${entityExpr} = 0`;
+    }
+  }
+);
+var QueryOperator = (operator, field) => QueryWrap(
+  (entityExpr, varExpr) => `${entityExpr} ${operator} ${varExpr}`,
+  field
+);
 var createQueryOperator = (operator) => (field) => QueryOperator(operator, field);
+var QueryEqual = createQueryOperator("=");
 var QueryGreater = createQueryOperator(">");
 var QueryGreaterEqual = createQueryOperator(">=");
 var QueryLess = createQueryOperator("<");
 var QueryLessEqual = createQueryOperator("<=");
 var QueryNotEqual = createQueryOperator("!=");
+var QueryJsonbHas = createQueryOperator("?");
+var createQueryArrayify = (newWrapper, singleFallbackWrapper) => createQueryWrap((entityExpr, varExpr, info) => {
+  const value = info.value;
+  const items = Array.isArray(value) ? value : typeof value === "string" ? value.split(",") : [value];
+  if (items.length === 1 && singleFallbackWrapper) {
+    const singleRes = singleFallbackWrapper(entityExpr, varExpr, info);
+    if (singleRes) {
+      return singleRes;
+    }
+  }
+  info.mutateValue(items);
+  const newVarExpr = `(:...${varExpr.slice(1)})`;
+  return newWrapper(entityExpr, newVarExpr, info);
+});
+var createQueryOperatorArrayify = (operator, singleFallback) => createQueryArrayify(
+  (entityExpr, varExpr) => `${entityExpr} ${operator} ${varExpr}`,
+  typeof singleFallback === "string" ? singleFallback.length ? (entityExpr, varExpr) => `${entityExpr} ${singleFallback} ${varExpr}` : void 0 : singleFallback
+);
+var QueryIn = createQueryOperatorArrayify("IN", "=");
+var QueryNotIn = createQueryOperatorArrayify("NOT IN", "!=");
 var QueryFullText = (options = {}) => {
   const configurationName = options.parser ? `nicot_parser_${options.parser}` : options.configuration || "english";
   const tsQueryFunction = options.tsQueryFunction || "websearch_to_tsquery";
@@ -721,7 +813,7 @@ var QueryFullText = (options = {}) => {
     QueryCondition((obj, qb, entityName, key) => {
       if (obj[key] == null) return;
       const fieldName = key;
-      const typeormField = key;
+      const typeormField = getQueryVarName(obj, key);
       const tsVectorStatement = `to_tsvector('${configurationName}', "${entityName}"."${fieldName}")`;
       const tsQueryStatement = `${tsQueryFunction}('${configurationName}', :${typeormField})`;
       qb.andWhere(`${tsVectorStatement} @@ ${tsQueryStatement}`, {
@@ -747,6 +839,36 @@ var QueryFullText = (options = {}) => {
     )
   ]);
 };
+var QueryAnd = (...decs) => {
+  const conditions = decs.map(
+    (dec) => reflector.getMetadataFromDecorator(dec, "queryCondition")
+  );
+  return QueryCondition(
+    (obj, qb, entityName, key) => conditions.forEach((cond) => cond(obj, qb, entityName, key))
+  );
+};
+var QueryOr = (...decs) => {
+  const conditions = decs.map(
+    (dec) => reflector.getMetadataFromDecorator(dec, "queryCondition")
+  );
+  return QueryCondition((obj, qb, entityName, key) => {
+    if (!conditions.length) {
+      return;
+    }
+    qb.andWhere(
+      new import_typeorm2.Brackets((orQb) => {
+        const innerBrackets = conditions.map(
+          (cond) => new import_typeorm2.Brackets((andQb) => {
+            cond(obj, andQb, entityName, key);
+          })
+        );
+        const [first, ...rest] = innerBrackets;
+        orQb.where(first);
+        rest.forEach((bracket) => orQb.orWhere(bracket));
+      })
+    );
+  });
+};
 
 // src/dto/cursor-pagination.ts
 var CursorPaginationDto = class {
@@ -819,10 +941,10 @@ function CursorPaginationReturnMessageDto(type) {
 }
 
 // src/crud-base.ts
-var import_typeorm6 = require("typeorm");
+var import_typeorm7 = require("typeorm");
 
 // src/bases/time-base.ts
-var import_typeorm2 = require("typeorm");
+var import_typeorm3 = require("typeorm");
 
 // src/bases/page-settings.ts
 var import_class_validator5 = require("class-validator");
@@ -899,26 +1021,26 @@ var TimeBase = class extends PageSettingsDto {
   }
 };
 __decorateClass([
-  (0, import_typeorm2.CreateDateColumn)({ select: false }),
+  (0, import_typeorm3.CreateDateColumn)({ select: false }),
   NotColumn(),
   NotInResult({ entityVersioningDate: true }),
   Reflect.metadata("design:type", Date)
 ], TimeBase.prototype, "createTime", 2);
 __decorateClass([
-  (0, import_typeorm2.UpdateDateColumn)({ select: false }),
+  (0, import_typeorm3.UpdateDateColumn)({ select: false }),
   NotColumn(),
   NotInResult({ entityVersioningDate: true }),
   Reflect.metadata("design:type", Date)
 ], TimeBase.prototype, "updateTime", 2);
 __decorateClass([
-  (0, import_typeorm2.DeleteDateColumn)({ select: false }),
+  (0, import_typeorm3.DeleteDateColumn)({ select: false }),
   NotColumn(),
   NotInResult({ entityVersioningDate: true }),
   Reflect.metadata("design:type", Date)
 ], TimeBase.prototype, "deleteTime", 2);
 
 // src/bases/id-base.ts
-var import_typeorm3 = require("typeorm");
+var import_typeorm4 = require("typeorm");
 var import_class_validator6 = require("class-validator");
 var import_nesties7 = require("nesties");
 function IdBase(idOptions = {}) {
@@ -938,7 +1060,7 @@ function IdBase(idOptions = {}) {
       columnExtras: { nullable: false, primary: true }
     }),
     Reflect.metadata("design:type", Number),
-    (0, import_typeorm3.Generated)("increment"),
+    (0, import_typeorm4.Generated)("increment"),
     QueryEqual()
   ]);
   dec(cl.prototype, "id");
@@ -979,10 +1101,10 @@ var import_lodash3 = __toESM(require("lodash"));
 var import_nesties8 = require("nesties");
 
 // src/utility/get-typeorm-relations.ts
-var import_typeorm4 = require("typeorm");
+var import_typeorm5 = require("typeorm");
 var import_lodash = __toESM(require("lodash"));
 function getTypeormRelations(cl) {
-  const relations = (0, import_typeorm4.getMetadataArgsStorage)().relations.filter(
+  const relations = (0, import_typeorm5.getMetadataArgsStorage)().relations.filter(
     (r) => r.target === cl
   );
   const typeormRelations = relations.map((relation) => {
@@ -1029,7 +1151,7 @@ function getTypeormRelations(cl) {
 }
 
 // src/utility/cursor-pagination-utils.ts
-var import_typeorm5 = require("typeorm");
+var import_typeorm6 = require("typeorm");
 var import_lodash2 = __toESM(require("lodash"));
 var import_superjson = __toESM(require("superjson"));
 
@@ -1248,8 +1370,8 @@ async function getPaginatedResult(qb, entityClass, entityAliasName, take, cursor
       ).filter((s) => !s.includes("__never__"));
       if (expressionMatrix.length) {
         qb.andWhere(
-          new import_typeorm5.Brackets((sqb) => {
-            const levelToBrackets = (level) => new import_typeorm5.Brackets((qb2) => {
+          new import_typeorm6.Brackets((sqb) => {
+            const levelToBrackets = (level) => new import_typeorm6.Brackets((qb2) => {
               level.forEach((expr, i) => {
                 if (i === 0) {
                   qb2.where(expr);
@@ -1366,11 +1488,14 @@ var CrudBase = class {
         cl,
         this.crudOptions.keepEntityVersioningDates
       );
+      if (cl === this.entityClass && this.crudOptions.outputFieldsToOmit) {
+        fields.push(...this.crudOptions.outputFieldsToOmit);
+      }
       for (const field of fields) {
         delete o[field];
       }
       visited.add(o);
-      for (const relation of this._typeormRelations) {
+      for (const relation of getTypeormRelations(cl)) {
         const propertyName = relation.propertyName;
         if (o[propertyName]) {
           if (Array.isArray(o[propertyName])) {
@@ -1411,7 +1536,7 @@ var CrudBase = class {
               // eslint-disable-next-line @typescript-eslint/ban-ts-comment
               // @ts-ignore
               where: {
-                id: (0, import_typeorm6.In)(chunk)
+                id: (0, import_typeorm7.In)(chunk)
               },
               select: this.crudOptions.createOrUpdate ? void 0 : ["id", "deleteTime"],
               withDeleted: true
@@ -1854,8 +1979,8 @@ function CrudService(entityClass, crudOptions = {}) {
 // src/restful.ts
 var import_common3 = require("@nestjs/common");
 var import_nesties10 = require("nesties");
-var import_swagger7 = require("@nestjs/swagger");
-var import_lodash4 = __toESM(require("lodash"));
+var import_swagger6 = require("@nestjs/swagger");
+var import_lodash5 = __toESM(require("lodash"));
 var import_nesties11 = require("nesties");
 
 // src/bases/base-restful-controller.ts
@@ -1871,175 +1996,249 @@ var BaseRestfulController = class {
   constructor(serviceOrRepo, _options = {}) {
     this._options = _options;
     if (serviceOrRepo instanceof CrudBase) {
-      this.service = serviceOrRepo;
+      this._service = serviceOrRepo;
     } else {
       const crudServiceClass = CrudService(this._options.entityClass, {
         relations: this._options.relations
       });
-      this.service = new crudServiceClass(serviceOrRepo);
+      this._service = new crudServiceClass(serviceOrRepo);
     }
   }
   findOne(id) {
-    return this.service.findOne(id);
+    return this._service.findOne(id);
   }
   findAll(dto) {
     if (this._options.paginateType === "cursor") {
-      return this.service.findAllCursorPaginated(dto);
+      return this._service.findAllCursorPaginated(dto);
     }
     if (this._options.paginateType === "offset") {
-      return this.service.findAll(dto);
+      return this._service.findAll(dto);
     }
     dto["recordsPerPage"] ??= 99999;
-    return this.service.findAll(dto);
+    return this._service.findAll(dto);
   }
   create(dto) {
-    return this.service.create(dto);
+    return this._service.create(dto);
   }
   update(id, dto) {
-    return this.service.update(id, dto);
+    return this._service.update(id, dto);
   }
   delete(id) {
-    return this.service.delete(id);
+    return this._service.delete(id);
   }
   import(data) {
-    return this.service.importEntities(data.data);
+    return this._service.importEntities(data.data);
   }
 };
 
 // src/utility/omit-type-exclude.ts
 var import_swagger5 = require("@nestjs/swagger");
-var import_class_transformer4 = require("class-transformer");
+var import_class_transformer3 = require("class-transformer");
 var OmitTypeExclude = (cl, keys) => {
   const omitted = (0, import_swagger5.OmitType)(cl, keys);
   for (const key of keys) {
-    (0, import_class_transformer4.Exclude)()(omitted.prototype, key);
+    (0, import_class_transformer3.Exclude)()(omitted.prototype, key);
   }
   return omitted;
 };
+var PickTypeExpose = (cl, keys) => {
+  const picked = (0, import_swagger5.OmitType)(
+    cl,
+    Object.keys(cl.prototype).filter((k) => !keys.includes(k))
+  );
+  for (const key of keys) {
+    (0, import_class_transformer3.Expose)()(picked.prototype, key);
+  }
+  return picked;
+};
 
 // src/utility/patch-column-in-get.ts
-var import_swagger6 = require("@nestjs/swagger");
 var import_nesties9 = require("nesties");
+var import_lodash4 = __toESM(require("lodash"));
+var import_constants = require("@nestjs/swagger/dist/constants");
 var PatchColumnsInGet = (cl, originalCl = cl, fieldsToOmit = []) => {
   const omit2 = new Set(fieldsToOmit);
-  const boolFields = getSpecificFields(originalCl || cl, "boolColumn").filter(
+  const useCl = originalCl || cl;
+  const mutateFields = getSpecificFields(useCl, "getMutator").filter(
     (f) => !omit2.has(f)
   );
-  for (const field of boolFields) {
+  for (const field of mutateFields) {
     const originalApiProp = (0, import_nesties9.getApiProperty)(originalCl, field);
-    (0, import_swagger6.ApiProperty)({
-      ...originalApiProp,
-      type: String,
-      required: false,
-      enum: ["0", "1"],
-      default: originalApiProp?.default === true ? "1" : originalApiProp?.default === false ? "0" : void 0
-    })(cl.prototype, field);
+    const info = reflector.get("getMutator", useCl, field);
+    Reflect.defineMetadata(
+      import_constants.DECORATORS.API_MODEL_PROPERTIES,
+      {
+        ...originalApiProp,
+        type: String,
+        required: false,
+        example: info.example ?? void 0,
+        enum: info.enum ?? void 0,
+        default: void 0,
+        ...info.apiPropertyExtras || {}
+      },
+      cl.prototype,
+      field
+    );
+  }
+  const queryableFieldsRemaining = import_lodash4.default.difference(
+    getSpecificFields(useCl, "queryCondition"),
+    mutateFields
+  );
+  for (const field of queryableFieldsRemaining) {
+    const originalApiProp = (0, import_nesties9.getApiProperty)(originalCl, field);
+    Reflect.defineMetadata(
+      import_constants.DECORATORS.API_MODEL_PROPERTIES,
+      {
+        ...originalApiProp,
+        default: void 0
+        // we remove every default value in get
+      },
+      cl.prototype,
+      field
+    );
   }
   return cl;
 };
 
+// src/utility/memorize.ts
+var Memorize = () => {
+  const cache = /* @__PURE__ */ new WeakMap();
+  return function(_target, propertyKey, descriptor) {
+    const getter = descriptor.get;
+    descriptor.get = function() {
+      if (cache.has(this)) return cache.get(this);
+      const value = getter.call(this);
+      cache.set(this, value);
+      return value;
+    };
+  };
+};
+
+// src/utility/mutate-pipe.ts
+var MutatorPipe = class {
+  constructor(entityClass) {
+    this.entityClass = entityClass;
+    this.mutatorFields = getSpecificFields(this.entityClass, "getMutator");
+  }
+  transform(obj) {
+    if (obj === null || typeof obj !== "object") {
+      return obj;
+    }
+    const newObj = { ...obj };
+    for (const field of this.mutatorFields) {
+      const v = newObj[field];
+      if (v == null) {
+        continue;
+      }
+      const mutator = reflector.get("getMutator", this.entityClass, field);
+      newObj[field] = mutator.mutator(v);
+    }
+    return newObj;
+  }
+};
+
 // src/restful.ts
 var getCurrentLevelRelations = (relations) => relations.filter((r) => !r.includes("."));
 var getNextLevelRelations = (relations, enteringField) => relations.filter((r) => r.includes(".") && r.startsWith(`${enteringField}.`)).map((r) => r.split(".").slice(1).join("."));
-var RestfulFactory = class _RestfulFactory {
+var _RestfulFactory = class _RestfulFactory {
   constructor(entityClass, options = {}, __resolveVisited = /* @__PURE__ */ new Map()) {
     this.entityClass = entityClass;
     this.options = options;
     this.__resolveVisited = __resolveVisited;
-    this.fieldsToOmit = import_lodash4.default.uniq([
+    if (options.relations) {
+      filterRelations(entityClass, options.relations);
+    }
+  }
+  getEntityClassName() {
+    return this.options.entityClassName || this.entityClass.name;
+  }
+  get fieldsToOmit() {
+    return import_lodash5.default.uniq([
       ...getSpecificFields(this.entityClass, "notColumn"),
       ...this.options.fieldsToOmit || [],
       ...getTypeormRelations(this.entityClass).map(
         (r) => r.propertyName
       )
     ]);
-    this.basicInputDto = OmitTypeExclude(
-      this.entityClass,
-      this.fieldsToOmit
-    );
-    this.createDto = (0, import_nesties11.RenameClass)(
-      OmitTypeExclude(
-        this.basicInputDto,
-        getSpecificFields(this.entityClass, "notWritable")
-      ),
+  }
+  get fieldsInCreateToOmit() {
+    return import_lodash5.default.uniq([
+      ...this.fieldsToOmit,
+      ...this.options.writeFieldsToOmit || [],
+      ...this.options.createFieldsToOmit || [],
+      ...getSpecificFields(this.entityClass, "notWritable"),
+      ...getSpecificFields(this.entityClass, "notCreatable")
+    ]);
+  }
+  get createDto() {
+    return (0, import_nesties11.RenameClass)(
+      OmitTypeExclude(this.entityClass, this.fieldsInCreateToOmit),
       `Create${this.entityClass.name}Dto`
     );
-    this.importDto = ImportDataDto(this.createDto);
-    this.fieldsInGetToOmit = import_lodash4.default.uniq([
+  }
+  get fieldsInUpdateToOmit() {
+    return import_lodash5.default.uniq([
       ...this.fieldsToOmit,
-      ...getSpecificFields(this.entityClass, "notQueryable")
+      ...this.options.writeFieldsToOmit || [],
+      ...this.options.updateFieldsToOmit || [],
+      ...getSpecificFields(this.entityClass, "notWritable"),
+      ...getSpecificFields(this.entityClass, "notChangeable")
     ]);
-    this.findAllDto = (0, import_nesties11.RenameClass)(
-      (0, import_swagger7.PartialType)(
-        PatchColumnsInGet(
-          OmitTypeExclude(
-            this.entityClass instanceof PageSettingsDto ? this.entityClass : (0, import_swagger7.IntersectionType)(
-              this.entityClass,
-              PageSettingsDto
-            ),
-            this.fieldsInGetToOmit
+  }
+  get updateDto() {
+    return (0, import_nesties11.RenameClass)(
+      (0, import_swagger6.PartialType)(OmitTypeExclude(this.entityClass, this.fieldsInUpdateToOmit)),
+      `Update${this.entityClass.name}Dto`
+    );
+  }
+  get importDto() {
+    return ImportDataDto(this.createDto);
+  }
+  get fieldsInGetToOmit() {
+    return import_lodash5.default.uniq([
+      ...this.fieldsToOmit,
+      ...getSpecificFields(this.entityClass, "notQueryable"),
+      ...import_lodash5.default.difference(
+        getSpecificFields(this.entityClass, "requireGetMutator"),
+        getSpecificFields(this.entityClass, "getMutator")
+      )
+    ]);
+  }
+  get queryableFields() {
+    return import_lodash5.default.difference(
+      getSpecificFields(this.entityClass, "queryCondition"),
+      this.fieldsInGetToOmit
+    );
+  }
+  get findAllDto() {
+    let cl = (0, import_swagger6.PartialType)(
+      PatchColumnsInGet(
+        OmitTypeExclude(
+          this.entityClass instanceof PageSettingsDto ? this.entityClass : (0, import_swagger6.IntersectionType)(
+            this.entityClass,
+            PageSettingsDto
           ),
-          this.entityClass,
           this.fieldsInGetToOmit
-        )
-      ),
-      `Find${this.entityClass.name}Dto`
+        ),
+        this.entityClass,
+        this.fieldsInGetToOmit
+      )
     );
-    this.findAllCursorPaginatedDto = (0, import_nesties11.RenameClass)(
-      (0, import_swagger7.IntersectionType)(
+    if (this.options.skipNonQueryableFields) {
+      cl = PickTypeExpose(cl, this.queryableFields);
+    }
+    return (0, import_nesties11.RenameClass)(cl, `Find${this.entityClass.name}Dto`);
+  }
+  get findAllCursorPaginatedDto() {
+    return (0, import_nesties11.RenameClass)(
+      (0, import_swagger6.IntersectionType)(
         OmitTypeExclude(this.findAllDto, ["pageCount"]),
         CursorPaginationDto
       ),
       `Find${this.entityClass.name}CursorPaginatedDto`
     );
-    this.updateDto = (0, import_nesties11.RenameClass)(
-      (0, import_swagger7.PartialType)(
-        OmitTypeExclude(
-          this.createDto,
-          getSpecificFields(this.entityClass, "notChangeable")
-        )
-      ),
-      `Update${this.entityClass.name}Dto`
-    );
-    this.entityResultDto = this.resolveEntityResultDto();
-    this.entityCreateResultDto = (0, import_nesties11.RenameClass)(
-      (0, import_swagger7.OmitType)(this.entityResultDto, [
-        ...getTypeormRelations(this.entityClass).map(
-          (r) => r.propertyName
-        ),
-        ...getSpecificFields(
-          this.entityClass,
-          "notColumn",
-          (m) => !m.keepInCreate
-        )
-      ]),
-      `${this.getEntityClassName()}CreateResultDto`
-    );
-    this.entityReturnMessageDto = (0, import_nesties10.ReturnMessageDto)(this.entityResultDto);
-    this.entityCreateReturnMessageDto = (0, import_nesties10.ReturnMessageDto)(
-      this.entityCreateResultDto
-    );
-    this.entityArrayReturnMessageDto = (0, import_nesties10.PaginatedReturnMessageDto)(
-      this.entityResultDto
-    );
-    this.entityCursorPaginationReturnMessageDto = CursorPaginationReturnMessageDto(this.entityResultDto);
-    this.importReturnMessageDto = (0, import_nesties10.ReturnMessageDto)([
-      ImportEntryDto(this.entityCreateResultDto)
-    ]);
-    // eslint-disable-next-line @typescript-eslint/ban-types
-    this.idType = Reflect.getMetadata(
-      "design:type",
-      this.entityClass.prototype,
-      "id"
-    );
-    if (options.relations) {
-      filterRelations(entityClass, options.relations);
-    }
-  }
-  getEntityClassName() {
-    return this.options.entityClassName || this.entityClass.name;
   }
-  resolveEntityResultDto() {
+  get entityResultDto() {
     const relations = getTypeormRelations(this.entityClass);
     const currentLevelRelations = this.options.relations && new Set(
       getCurrentLevelRelations(
@@ -2054,7 +2253,7 @@ var RestfulFactory = class _RestfulFactory {
       ...this.options.outputFieldsToOmit || [],
       ...this.options.relations ? relations.map((r) => r.propertyName).filter((r) => !currentLevelRelations.has(r)) : []
     ]);
-    const resultDto = (0, import_swagger7.OmitType)(this.entityClass, [...outputFieldsToOmit]);
+    const resultDto = (0, import_swagger6.OmitType)(this.entityClass, [...outputFieldsToOmit]);
     for (const relation of relations) {
       if (outputFieldsToOmit.has(relation.propertyName)) continue;
       if (nonTransformableTypes.has(relation.propertyClass)) continue;
@@ -2063,7 +2262,7 @@ var RestfulFactory = class _RestfulFactory {
           this.entityClass,
           relation.propertyName
         );
-        (0, import_swagger7.ApiProperty)({
+        (0, import_swagger6.ApiProperty)({
           ...oldApiProperty,
           required: false,
           type: () => relation.isArray ? [useClass[0]] : useClass[0]
@@ -2079,7 +2278,7 @@ var RestfulFactory = class _RestfulFactory {
         const relationFactory = new _RestfulFactory(
           relation.propertyClass,
           {
-            entityClassName: `${this.getEntityClassName()}${this.options.relations ? (0, import_lodash4.upperFirst)(relation.propertyName) : relation.propertyClass.name}`,
+            entityClassName: `${this.getEntityClassName()}${this.options.relations ? (0, import_lodash5.upperFirst)(relation.propertyName) : relation.propertyClass.name}`,
             relations: this.options.relations && getNextLevelRelations(
               this.options.relations.map(extractRelationName),
               relation.propertyName
@@ -2103,7 +2302,7 @@ var RestfulFactory = class _RestfulFactory {
     ).filter((f) => !outputFieldsToOmit.has(f));
     for (const field of notRequiredButHasDefaultFields) {
       const oldApiProperty = (0, import_nesties10.getApiProperty)(resultDto, field);
-      (0, import_swagger7.ApiProperty)({
+      (0, import_swagger6.ApiProperty)({
         ...oldApiProperty,
         required: true
       })(resultDto.prototype, field);
@@ -2118,6 +2317,40 @@ var RestfulFactory = class _RestfulFactory {
     }
     return res;
   }
+  get entityCreateResultDto() {
+    return (0, import_nesties11.RenameClass)(
+      (0, import_swagger6.OmitType)(this.entityResultDto, [
+        ...getTypeormRelations(this.entityClass).map(
+          (r) => r.propertyName
+        ),
+        ...getSpecificFields(
+          this.entityClass,
+          "notColumn",
+          (m) => !m.keepInCreate
+        )
+      ]),
+      `${this.getEntityClassName()}CreateResultDto`
+    );
+  }
+  get entityReturnMessageDto() {
+    return (0, import_nesties10.ReturnMessageDto)(this.entityResultDto);
+  }
+  get entityCreateReturnMessageDto() {
+    return (0, import_nesties10.ReturnMessageDto)(this.entityCreateResultDto);
+  }
+  get entityArrayReturnMessageDto() {
+    return (0, import_nesties10.PaginatedReturnMessageDto)(this.entityResultDto);
+  }
+  get entityCursorPaginationReturnMessageDto() {
+    return CursorPaginationReturnMessageDto(this.entityResultDto);
+  }
+  get importReturnMessageDto() {
+    return (0, import_nesties10.ReturnMessageDto)([ImportEntryDto(this.entityCreateResultDto)]);
+  }
+  // eslint-disable-next-line @typescript-eslint/ban-types
+  get idType() {
+    return Reflect.getMetadata("design:type", this.entityClass.prototype, "id");
+  }
   usePrefix(methodDec, path) {
     if (path) {
       if (this.options.prefix) {
@@ -2137,31 +2370,31 @@ var RestfulFactory = class _RestfulFactory {
     return (0, import_nesties10.MergeMethodDecorators)([
       this.usePrefix(import_common3.Post),
       (0, import_common3.HttpCode)(200),
-      (0, import_swagger7.ApiOperation)({
+      (0, import_swagger6.ApiOperation)({
         summary: `Create a new ${this.getEntityClassName()}`,
         ...extras
       }),
-      (0, import_swagger7.ApiBody)({ type: this.createDto }),
-      (0, import_swagger7.ApiOkResponse)({ type: this.entityCreateReturnMessageDto }),
-      (0, import_swagger7.ApiBadRequestResponse)({
+      (0, import_swagger6.ApiBody)({ type: this.createDto }),
+      (0, import_swagger6.ApiOkResponse)({ type: this.entityCreateReturnMessageDto }),
+      (0, import_swagger6.ApiBadRequestResponse)({
         type: import_nesties10.BlankReturnMessageDto,
         description: `The ${this.getEntityClassName()} is not valid`
       })
     ]);
   }
   createParam() {
-    return (0, import_common3.Body)(CreatePipe());
+    return (0, import_common3.Body)((0, import_nesties10.DataPipe)(), OmitPipe(this.fieldsInCreateToOmit));
   }
   findOne(extras = {}) {
     return (0, import_nesties10.MergeMethodDecorators)([
       this.usePrefix(import_common3.Get, ":id"),
-      (0, import_swagger7.ApiOperation)({
+      (0, import_swagger6.ApiOperation)({
         summary: `Find a ${this.getEntityClassName()} by id`,
         ...extras
       }),
-      (0, import_swagger7.ApiParam)({ name: "id", type: this.idType, required: true }),
-      (0, import_swagger7.ApiOkResponse)({ type: this.entityReturnMessageDto }),
-      (0, import_swagger7.ApiNotFoundResponse)({
+      (0, import_swagger6.ApiParam)({ name: "id", type: this.idType, required: true }),
+      (0, import_swagger6.ApiOkResponse)({ type: this.entityReturnMessageDto }),
+      (0, import_swagger6.ApiNotFoundResponse)({
         type: import_nesties10.BlankReturnMessageDto,
         description: `The ${this.getEntityClassName()} with the given id was not found`
       })
@@ -2177,78 +2410,82 @@ var RestfulFactory = class _RestfulFactory {
   findAll(extras = {}) {
     return (0, import_nesties10.MergeMethodDecorators)([
       this.usePrefix(import_common3.Get),
-      (0, import_swagger7.ApiOperation)({
+      (0, import_swagger6.ApiOperation)({
         summary: `Find all ${this.getEntityClassName()}`,
         ...extras
       }),
-      (0, import_swagger7.ApiOkResponse)({ type: this.entityArrayReturnMessageDto })
+      (0, import_swagger6.ApiOkResponse)({ type: this.entityArrayReturnMessageDto })
     ]);
   }
   findAllCursorPaginated(extras = {}) {
     return (0, import_nesties10.MergeMethodDecorators)([
       this.usePrefix(import_common3.Get),
-      (0, import_swagger7.ApiOperation)({
+      (0, import_swagger6.ApiOperation)({
         summary: `Find all ${this.getEntityClassName()}`,
         ...extras
       }),
-      (0, import_swagger7.ApiOkResponse)({ type: this.entityCursorPaginationReturnMessageDto })
+      (0, import_swagger6.ApiOkResponse)({ type: this.entityCursorPaginationReturnMessageDto })
     ]);
   }
-  getBoolColumns() {
-    const boolColumns = getSpecificFields(this.entityClass, "boolColumn");
-    return import_lodash4.default.difference(boolColumns, this.fieldsInGetToOmit);
+  getMutatorColumns() {
+    const mutatorColumns = getSpecificFields(this.entityClass, "getMutator");
+    return import_lodash5.default.difference(mutatorColumns, this.fieldsInGetToOmit);
   }
   findAllParam() {
-    const boolColumns = this.getBoolColumns();
-    if (boolColumns.length) {
-      return (0, import_common3.Query)(new ParseBoolObjectPipe(boolColumns), GetPipe());
+    const mutatorColumns = this.getMutatorColumns();
+    const restPipes = [OptionalDataPipe(), OmitPipe(this.fieldsInGetToOmit)];
+    if (this.options.skipNonQueryableFields) {
+      restPipes.push(PickPipe(this.queryableFields));
+    }
+    if (mutatorColumns.length) {
+      return (0, import_common3.Query)(new MutatorPipe(this.entityClass), ...restPipes);
     } else {
-      return (0, import_common3.Query)(GetPipe());
+      return (0, import_common3.Query)(...restPipes);
     }
   }
   update(extras = {}) {
     return (0, import_nesties10.MergeMethodDecorators)([
       this.usePrefix(import_common3.Patch, ":id"),
       (0, import_common3.HttpCode)(200),
-      (0, import_swagger7.ApiOperation)({
+      (0, import_swagger6.ApiOperation)({
         summary: `Update a ${this.getEntityClassName()} by id`,
         ...extras
       }),
-      (0, import_swagger7.ApiParam)({ name: "id", type: this.idType, required: true }),
-      (0, import_swagger7.ApiBody)({ type: this.updateDto }),
-      (0, import_swagger7.ApiOkResponse)({ type: import_nesties10.BlankReturnMessageDto }),
-      (0, import_swagger7.ApiNotFoundResponse)({
+      (0, import_swagger6.ApiParam)({ name: "id", type: this.idType, required: true }),
+      (0, import_swagger6.ApiBody)({ type: this.updateDto }),
+      (0, import_swagger6.ApiOkResponse)({ type: import_nesties10.BlankReturnMessageDto }),
+      (0, import_swagger6.ApiNotFoundResponse)({
         type: import_nesties10.BlankReturnMessageDto,
         description: `The ${this.getEntityClassName()} with the given id was not found`
       }),
-      (0, import_swagger7.ApiBadRequestResponse)({
+      (0, import_swagger6.ApiBadRequestResponse)({
         type: import_nesties10.BlankReturnMessageDto,
         description: `The ${this.getEntityClassName()} is not valid`
       }),
-      (0, import_swagger7.ApiInternalServerErrorResponse)({
+      (0, import_swagger6.ApiInternalServerErrorResponse)({
         type: import_nesties10.BlankReturnMessageDto,
         description: "Internal error"
       })
     ]);
   }
   updateParam() {
-    return (0, import_common3.Body)(UpdatePipe());
+    return (0, import_common3.Body)(OptionalDataPipe(), OmitPipe(this.fieldsInUpdateToOmit));
   }
   delete(extras = {}) {
     return (0, import_nesties10.MergeMethodDecorators)([
       this.usePrefix(import_common3.Delete, ":id"),
       (0, import_common3.HttpCode)(200),
-      (0, import_swagger7.ApiOperation)({
+      (0, import_swagger6.ApiOperation)({
         summary: `Delete a ${this.getEntityClassName()} by id`,
         ...extras
       }),
-      (0, import_swagger7.ApiParam)({ name: "id", type: this.idType, required: true }),
-      (0, import_swagger7.ApiOkResponse)({ type: import_nesties10.BlankReturnMessageDto }),
-      (0, import_swagger7.ApiNotFoundResponse)({
+      (0, import_swagger6.ApiParam)({ name: "id", type: this.idType, required: true }),
+      (0, import_swagger6.ApiOkResponse)({ type: import_nesties10.BlankReturnMessageDto }),
+      (0, import_swagger6.ApiNotFoundResponse)({
         type: import_nesties10.BlankReturnMessageDto,
         description: `The ${this.getEntityClassName()} with the given id was not found`
       }),
-      (0, import_swagger7.ApiInternalServerErrorResponse)({
+      (0, import_swagger6.ApiInternalServerErrorResponse)({
         type: import_nesties10.BlankReturnMessageDto,
         description: "Internal error"
       })
@@ -2258,13 +2495,13 @@ var RestfulFactory = class _RestfulFactory {
     return (0, import_nesties10.MergeMethodDecorators)([
       (0, import_common3.Post)("import"),
       (0, import_common3.HttpCode)(200),
-      (0, import_swagger7.ApiOperation)({
+      (0, import_swagger6.ApiOperation)({
         summary: `Import ${this.getEntityClassName()}`,
         ...extras
       }),
-      (0, import_swagger7.ApiBody)({ type: this.importDto }),
-      (0, import_swagger7.ApiOkResponse)({ type: this.importReturnMessageDto }),
-      (0, import_swagger7.ApiInternalServerErrorResponse)({
+      (0, import_swagger6.ApiBody)({ type: this.importDto }),
+      (0, import_swagger6.ApiOkResponse)({ type: this.importReturnMessageDto }),
+      (0, import_swagger6.ApiInternalServerErrorResponse)({
         type: import_nesties10.BlankReturnMessageDto,
         description: "Internal error"
       })
@@ -2298,7 +2535,7 @@ var RestfulFactory = class _RestfulFactory {
       },
       findAll: {
         paramTypes: [
-          routeOptions.paginateType === "cursor" ? this.findAllCursorPaginatedDto : routeOptions.paginateType === "none" ? (0, import_swagger7.OmitType)(this.findAllDto, [
+          routeOptions.paginateType === "cursor" ? this.findAllCursorPaginatedDto : routeOptions.paginateType === "none" ? (0, import_swagger6.OmitType)(this.findAllDto, [
             "pageCount",
             "recordsPerPage"
           ]) : this.findAllDto
@@ -2386,15 +2623,135 @@ var RestfulFactory = class _RestfulFactory {
   crudService(options = {}) {
     return CrudService(this.entityClass, {
       relations: this.options.relations,
+      outputFieldsToOmit: this.options.outputFieldsToOmit,
       ...options
     });
   }
 };
+__decorateClass([
+  Memorize()
+], _RestfulFactory.prototype, "fieldsToOmit", 1);
+__decorateClass([
+  Memorize()
+], _RestfulFactory.prototype, "fieldsInCreateToOmit", 1);
+__decorateClass([
+  Memorize()
+], _RestfulFactory.prototype, "createDto", 1);
+__decorateClass([
+  Memorize()
+], _RestfulFactory.prototype, "fieldsInUpdateToOmit", 1);
+__decorateClass([
+  Memorize()
+], _RestfulFactory.prototype, "updateDto", 1);
+__decorateClass([
+  Memorize()
+], _RestfulFactory.prototype, "importDto", 1);
+__decorateClass([
+  Memorize()
+], _RestfulFactory.prototype, "fieldsInGetToOmit", 1);
+__decorateClass([
+  Memorize()
+], _RestfulFactory.prototype, "queryableFields", 1);
+__decorateClass([
+  Memorize()
+], _RestfulFactory.prototype, "findAllDto", 1);
+__decorateClass([
+  Memorize()
+], _RestfulFactory.prototype, "findAllCursorPaginatedDto", 1);
+__decorateClass([
+  Memorize()
+], _RestfulFactory.prototype, "entityResultDto", 1);
+__decorateClass([
+  Memorize()
+], _RestfulFactory.prototype, "entityCreateResultDto", 1);
+__decorateClass([
+  Memorize()
+], _RestfulFactory.prototype, "entityReturnMessageDto", 1);
+__decorateClass([
+  Memorize()
+], _RestfulFactory.prototype, "entityCreateReturnMessageDto", 1);
+__decorateClass([
+  Memorize()
+], _RestfulFactory.prototype, "entityArrayReturnMessageDto", 1);
+__decorateClass([
+  Memorize()
+], _RestfulFactory.prototype, "entityCursorPaginationReturnMessageDto", 1);
+__decorateClass([
+  Memorize()
+], _RestfulFactory.prototype, "importReturnMessageDto", 1);
+__decorateClass([
+  Memorize()
+], _RestfulFactory.prototype, "idType", 1);
+var RestfulFactory = _RestfulFactory;
+
+// src/utility/query.ts
+function createQueryCondition(cond) {
+  return (obj, qb, entityName, ...fields) => {
+    for (const field of fields) {
+      if (obj[field] == null) {
+        continue;
+      }
+      const ret = cond(obj, qb, entityName, field);
+      if (typeof ret === "string") {
+        qb.andWhere(ret);
+      } else if (typeof ret === "object" && typeof ret["query"] === "string") {
+        const _ret = ret;
+        qb.andWhere(_ret.query, _ret.params);
+      }
+    }
+    return qb;
+  };
+}
+var applyQueryProperty = createQueryCondition(
+  (obj, qb, entityName, field) => qb.andWhere(`${entityName}.${field} = :${field}`, { [field]: obj[field] })
+);
+var applyQueryPropertyLike = createQueryCondition(
+  (obj, qb, entityName, field) => qb.andWhere(`${entityName}.${field} like (:${field} || '%')`, {
+    [field]: obj[field]
+  })
+);
+var applyQueryPropertySearch = createQueryCondition(
+  (obj, qb, entityName, field) => qb.andWhere(`${entityName}.${field} like ('%' || :${field} || '%')`, {
+    [field]: obj[field]
+  })
+);
+var applyQueryPropertyZeroNullable = createQueryCondition(
+  (obj, qb, entityName, field) => {
+    if ([0, "0"].indexOf(obj[field]) !== -1) {
+      qb.andWhere(`${entityName}.${field} IS NULL`);
+    } else {
+      qb.andWhere(`${entityName}.${field} = :${field}`, {
+        [field]: obj[field]
+      });
+    }
+  }
+);
+var applyQueryMatchBoolean = createQueryCondition(
+  (obj, qb, entityName, field) => {
+    const value = parseBool(obj[field]);
+    if (value === true) {
+      qb.andWhere(`${entityName}.${field} = TRUE`);
+    }
+    if (value === false) {
+      qb.andWhere(`${entityName}.${field} = FALSE`);
+    }
+  }
+);
+var applyQueryMatchBooleanMySQL = createQueryCondition(
+  (obj, qb, entityName, field) => {
+    const value = parseBool(obj[field]);
+    if (value === true) {
+      qb.andWhere(`${entityName}.${field} = 1`);
+    }
+    if (value === false) {
+      qb.andWhere(`${entityName}.${field} = 0`);
+    }
+  }
+);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   BlankCursorPaginationReturnMessageDto,
   BoolColumn,
-  CreatePipe,
   CrudBase,
   CrudService,
   CursorPaginationDto,
@@ -2403,7 +2760,14 @@ var RestfulFactory = class _RestfulFactory {
   EnumColumn,
   FloatColumn,
   GenericCursorPaginationReturnMessageDto,
-  GetPipe,
+  GetMutator,
+  GetMutatorBool,
+  GetMutatorFloat,
+  GetMutatorFloatSeparated,
+  GetMutatorInt,
+  GetMutatorIntSeparated,
+  GetMutatorJson,
+  GetMutatorStringSeparated,
   IdBase,
   ImportDataBaseDto,
   ImportDataDto,
@@ -2414,10 +2778,15 @@ var RestfulFactory = class _RestfulFactory {
   JsonColumn,
   NotChangeable,
   NotColumn,
+  NotCreatable,
   NotInResult,
   NotQueryable,
   NotWritable,
+  OmitPipe,
+  OptionalDataPipe,
   PageSettingsDto,
+  PickPipe,
+  QueryAnd,
   QueryColumn,
   QueryCondition,
   QueryEqual,
@@ -2425,16 +2794,24 @@ var RestfulFactory = class _RestfulFactory {
   QueryFullText,
   QueryGreater,
   QueryGreaterEqual,
+  QueryIn,
+  QueryJsonbHas,
   QueryLess,
   QueryLessEqual,
   QueryLike,
+  QueryManual,
   QueryMatchBoolean,
   QueryMatchBooleanMySQL,
   QueryNotEqual,
+  QueryNotIn,
   QueryOperator,
+  QueryOr,
   QuerySearch,
+  QueryWrap,
+  QueryWrapInfo,
   Relation,
   RelationComputed,
+  RequireGetMutator,
   RestfulFactory,
   SimpleJsonColumn,
   StringColumn,
@@ -2442,7 +2819,6 @@ var RestfulFactory = class _RestfulFactory {
   StringJsonColumn,
   TextColumn,
   TimeBase,
-  UpdatePipe,
   UuidColumn,
   applyQueryMatchBoolean,
   applyQueryMatchBooleanMySQL,
@@ -2450,8 +2826,12 @@ var RestfulFactory = class _RestfulFactory {
   applyQueryPropertyLike,
   applyQueryPropertySearch,
   applyQueryPropertyZeroNullable,
+  createGetMutator,
+  createQueryArrayify,
   createQueryCondition,
   createQueryOperator,
+  createQueryOperatorArrayify,
+  createQueryWrap,
   ...require("nesties")
 });
 //# sourceMappingURL=index.cjs.map