nicot 1.1.38 → 1.2.1

package/dist/index.mjs

@@ -67,7 +67,6 @@ import {
 } from "nesties";
 
 // src/decorators/access.ts
-import { Expose } from "class-transformer";
 import { IsOptional } from "class-validator";
 
 // src/utility/metadata.ts
@@ -94,13 +93,14 @@ function getNotInResultFields(obj, keepEntityVersioningDates = false) {
 // src/decorators/access.ts
 import { MergePropertyDecorators } from "nesties";
 var NotWritable = () => MergePropertyDecorators([
-  Expose({ groups: ["r"] }),
   IsOptional(),
-  Metadata.set("notWritable", true, "notWritableFields"),
-  Metadata.set("notChangeable", true, "notChangeableFields")
+  Metadata.set("notWritable", true, "notWritableFields")
+]);
+var NotCreatable = () => MergePropertyDecorators([
+  IsOptional(),
+  Metadata.set("notCreatable", true, "notCreatableFields")
 ]);
 var NotChangeable = () => MergePropertyDecorators([
-  Expose({ groups: ["r", "c"] }),
   Metadata.set("notChangeable", true, "notChangeableFields")
 ]);
 var NotQueryable = () => Metadata.set("notQueryable", true, "notQueryableFields");
@@ -239,21 +239,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(
@@ -454,12 +478,12 @@ var BoolColumn = (options = {}) => MergePropertyDecorators2([
   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 = getClassFromClassOrArray2(definition);
   return MergePropertyDecorators2([
-    NotQueryable(),
+    RequireGetMutator(),
     Type2(() => cl),
     ValidateNested2(),
     Column(options.columnType || columnType, {
@@ -507,89 +531,48 @@ var RelationComputed = (type) => (obj, propertyKey) => {
 
 // src/decorators/pipes.ts
 import { ValidationPipe } from "@nestjs/common";
-var CreatePipe = () => new ValidationPipe({
-  transform: true,
-  transformOptions: { groups: ["c"], enableImplicitConversion: true }
-});
-var GetPipe = () => new ValidationPipe({
+var OptionalDataPipe = () => new ValidationPipe({
   transform: true,
-  transformOptions: { groups: ["r"], enableImplicitConversion: true },
+  transformOptions: { enableImplicitConversion: true },
   skipMissingProperties: true,
   skipNullProperties: true,
   skipUndefinedProperties: true
 });
-var UpdatePipe = () => new 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
 import { MergePropertyDecorators as MergePropertyDecorators3 } from "nesties";
@@ -624,31 +607,118 @@ var getSubject = (qb, alias) => {
 };
 
 // src/decorators/query.ts
+import { Brackets } from "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";
@@ -656,7 +726,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}`, {
@@ -682,6 +752,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 Brackets((orQb) => {
+        const innerBrackets = conditions.map(
+          (cond) => new 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 {
@@ -974,7 +1074,7 @@ function getTypeormRelations(cl) {
 }
 
 // src/utility/cursor-pagination-utils.ts
-import { Brackets } from "typeorm";
+import { Brackets as Brackets2 } from "typeorm";
 import _2 from "lodash";
 import SJSON from "superjson";
 
@@ -1193,8 +1293,8 @@ async function getPaginatedResult(qb, entityClass, entityAliasName, take, cursor
       ).filter((s) => !s.includes("__never__"));
       if (expressionMatrix.length) {
         qb.andWhere(
-          new Brackets((sqb) => {
-            const levelToBrackets = (level) => new Brackets((qb2) => {
+          new Brackets2((sqb) => {
+            const levelToBrackets = (level) => new Brackets2((qb2) => {
               level.forEach((expr, i) => {
                 if (i === 0) {
                   qb2.where(expr);
@@ -1311,6 +1411,9 @@ 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];
       }
@@ -1813,7 +1916,8 @@ import {
   MergeMethodDecorators,
   PaginatedReturnMessageDto as PaginatedReturnMessageDto2,
   ReturnMessageDto as ReturnMessageDto2,
-  getApiProperty as getApiProperty2
+  getApiProperty as getApiProperty2,
+  DataPipe
 } from "nesties";
 import {
   ApiBadRequestResponse,
@@ -1823,12 +1927,12 @@ import {
   ApiOkResponse,
   ApiOperation,
   ApiParam,
-  ApiProperty as ApiProperty6,
+  ApiProperty as ApiProperty5,
   IntersectionType,
   OmitType as OmitType2,
   PartialType
 } from "@nestjs/swagger";
-import _4, { upperFirst } from "lodash";
+import _5, { upperFirst } from "lodash";
 import { RenameClass } from "nesties";
 
 // src/bases/base-restful-controller.ts
@@ -1844,44 +1948,44 @@ 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
 import { OmitType } from "@nestjs/swagger";
-import { Exclude as Exclude2 } from "class-transformer";
+import { Exclude as Exclude2, Expose } from "class-transformer";
 var OmitTypeExclude = (cl, keys) => {
   const omitted = OmitType(cl, keys);
   for (const key of keys) {
@@ -1889,130 +1993,204 @@ var OmitTypeExclude = (cl, keys) => {
   }
   return omitted;
 };
+var PickTypeExpose = (cl, keys) => {
+  const picked = OmitType(
+    cl,
+    Object.keys(cl.prototype).filter((k) => !keys.includes(k))
+  );
+  for (const key of keys) {
+    Expose()(picked.prototype, key);
+  }
+  return picked;
+};
 
 // src/utility/patch-column-in-get.ts
-import { ApiProperty as ApiProperty5 } from "@nestjs/swagger";
 import { getApiProperty } from "nesties";
+import _4 from "lodash";
+import { DECORATORS } from "@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 = getApiProperty(originalCl, field);
-    ApiProperty5({
-      ...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(
+      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 = _4.difference(
+    getSpecificFields(useCl, "queryCondition"),
+    mutateFields
+  );
+  for (const field of queryableFieldsRemaining) {
+    const originalApiProp = getApiProperty(originalCl, field);
+    Reflect.defineMetadata(
+      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 = _4.uniq([
+    if (options.relations) {
+      filterRelations(entityClass, options.relations);
+    }
+  }
+  getEntityClassName() {
+    return this.options.entityClassName || this.entityClass.name;
+  }
+  get fieldsToOmit() {
+    return _5.uniq([
       ...getSpecificFields(this.entityClass, "notColumn"),
       ...this.options.fieldsToOmit || [],
       ...getTypeormRelations(this.entityClass).map(
         (r) => r.propertyName
       )
     ]);
-    this.basicInputDto = OmitTypeExclude(
-      this.entityClass,
-      this.fieldsToOmit
-    );
-    this.createDto = RenameClass(
-      OmitTypeExclude(
-        this.basicInputDto,
-        getSpecificFields(this.entityClass, "notWritable")
-      ),
+  }
+  get fieldsInCreateToOmit() {
+    return _5.uniq([
+      ...this.fieldsToOmit,
+      ...this.options.writeFieldsToOmit || [],
+      ...this.options.createFieldsToOmit || [],
+      ...getSpecificFields(this.entityClass, "notWritable"),
+      ...getSpecificFields(this.entityClass, "notCreatable")
+    ]);
+  }
+  get createDto() {
+    return RenameClass(
+      OmitTypeExclude(this.entityClass, this.fieldsInCreateToOmit),
       `Create${this.entityClass.name}Dto`
     );
-    this.importDto = ImportDataDto(this.createDto);
-    this.fieldsInGetToOmit = _4.uniq([
+  }
+  get fieldsInUpdateToOmit() {
+    return _5.uniq([
       ...this.fieldsToOmit,
-      ...getSpecificFields(this.entityClass, "notQueryable")
+      ...this.options.writeFieldsToOmit || [],
+      ...this.options.updateFieldsToOmit || [],
+      ...getSpecificFields(this.entityClass, "notWritable"),
+      ...getSpecificFields(this.entityClass, "notChangeable")
     ]);
-    this.findAllDto = RenameClass(
-      PartialType(
-        PatchColumnsInGet(
-          OmitTypeExclude(
-            this.entityClass instanceof PageSettingsDto ? this.entityClass : IntersectionType(
-              this.entityClass,
-              PageSettingsDto
-            ),
-            this.fieldsInGetToOmit
+  }
+  get updateDto() {
+    return RenameClass(
+      PartialType(OmitTypeExclude(this.entityClass, this.fieldsInUpdateToOmit)),
+      `Update${this.entityClass.name}Dto`
+    );
+  }
+  get importDto() {
+    return ImportDataDto(this.createDto);
+  }
+  get fieldsInGetToOmit() {
+    return _5.uniq([
+      ...this.fieldsToOmit,
+      ...getSpecificFields(this.entityClass, "notQueryable"),
+      ..._5.difference(
+        getSpecificFields(this.entityClass, "requireGetMutator"),
+        getSpecificFields(this.entityClass, "getMutator")
+      )
+    ]);
+  }
+  get queryableFields() {
+    return _5.difference(
+      getSpecificFields(this.entityClass, "queryCondition"),
+      this.fieldsInGetToOmit
+    );
+  }
+  get findAllDto() {
+    let cl = PartialType(
+      PatchColumnsInGet(
+        OmitTypeExclude(
+          this.entityClass instanceof PageSettingsDto ? this.entityClass : IntersectionType(
+            this.entityClass,
+            PageSettingsDto
           ),
-          this.entityClass,
           this.fieldsInGetToOmit
-        )
-      ),
-      `Find${this.entityClass.name}Dto`
+        ),
+        this.entityClass,
+        this.fieldsInGetToOmit
+      )
     );
-    this.findAllCursorPaginatedDto = RenameClass(
+    if (this.options.skipNonQueryableFields) {
+      cl = PickTypeExpose(cl, this.queryableFields);
+    }
+    return RenameClass(cl, `Find${this.entityClass.name}Dto`);
+  }
+  get findAllCursorPaginatedDto() {
+    return RenameClass(
       IntersectionType(
         OmitTypeExclude(this.findAllDto, ["pageCount"]),
         CursorPaginationDto
       ),
       `Find${this.entityClass.name}CursorPaginatedDto`
     );
-    this.updateDto = RenameClass(
-      PartialType(
-        OmitTypeExclude(
-          this.createDto,
-          getSpecificFields(this.entityClass, "notChangeable")
-        )
-      ),
-      `Update${this.entityClass.name}Dto`
-    );
-    this.entityResultDto = this.resolveEntityResultDto();
-    this.entityCreateResultDto = RenameClass(
-      OmitType2(this.entityResultDto, [
-        ...getTypeormRelations(this.entityClass).map(
-          (r) => r.propertyName
-        ),
-        ...getSpecificFields(
-          this.entityClass,
-          "notColumn",
-          (m) => !m.keepInCreate
-        )
-      ]),
-      `${this.getEntityClassName()}CreateResultDto`
-    );
-    this.entityReturnMessageDto = ReturnMessageDto2(this.entityResultDto);
-    this.entityCreateReturnMessageDto = ReturnMessageDto2(
-      this.entityCreateResultDto
-    );
-    this.entityArrayReturnMessageDto = PaginatedReturnMessageDto2(
-      this.entityResultDto
-    );
-    this.entityCursorPaginationReturnMessageDto = CursorPaginationReturnMessageDto(this.entityResultDto);
-    this.importReturnMessageDto = ReturnMessageDto2([
-      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(
@@ -2036,7 +2214,7 @@ var RestfulFactory = class _RestfulFactory {
           this.entityClass,
           relation.propertyName
         );
-        ApiProperty6({
+        ApiProperty5({
           ...oldApiProperty,
           required: false,
           type: () => relation.isArray ? [useClass[0]] : useClass[0]
@@ -2076,7 +2254,7 @@ var RestfulFactory = class _RestfulFactory {
     ).filter((f) => !outputFieldsToOmit.has(f));
     for (const field of notRequiredButHasDefaultFields) {
       const oldApiProperty = getApiProperty2(resultDto, field);
-      ApiProperty6({
+      ApiProperty5({
         ...oldApiProperty,
         required: true
       })(resultDto.prototype, field);
@@ -2091,6 +2269,40 @@ var RestfulFactory = class _RestfulFactory {
     }
     return res;
   }
+  get entityCreateResultDto() {
+    return RenameClass(
+      OmitType2(this.entityResultDto, [
+        ...getTypeormRelations(this.entityClass).map(
+          (r) => r.propertyName
+        ),
+        ...getSpecificFields(
+          this.entityClass,
+          "notColumn",
+          (m) => !m.keepInCreate
+        )
+      ]),
+      `${this.getEntityClassName()}CreateResultDto`
+    );
+  }
+  get entityReturnMessageDto() {
+    return ReturnMessageDto2(this.entityResultDto);
+  }
+  get entityCreateReturnMessageDto() {
+    return ReturnMessageDto2(this.entityCreateResultDto);
+  }
+  get entityArrayReturnMessageDto() {
+    return PaginatedReturnMessageDto2(this.entityResultDto);
+  }
+  get entityCursorPaginationReturnMessageDto() {
+    return CursorPaginationReturnMessageDto(this.entityResultDto);
+  }
+  get importReturnMessageDto() {
+    return ReturnMessageDto2([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) {
@@ -2123,7 +2335,7 @@ var RestfulFactory = class _RestfulFactory {
     ]);
   }
   createParam() {
-    return Body(CreatePipe());
+    return Body(DataPipe(), OmitPipe(this.fieldsInCreateToOmit));
   }
   findOne(extras = {}) {
     return MergeMethodDecorators([
@@ -2167,16 +2379,20 @@ var RestfulFactory = class _RestfulFactory {
       ApiOkResponse({ type: this.entityCursorPaginationReturnMessageDto })
     ]);
   }
-  getBoolColumns() {
-    const boolColumns = getSpecificFields(this.entityClass, "boolColumn");
-    return _4.difference(boolColumns, this.fieldsInGetToOmit);
+  getMutatorColumns() {
+    const mutatorColumns = getSpecificFields(this.entityClass, "getMutator");
+    return _5.difference(mutatorColumns, this.fieldsInGetToOmit);
   }
   findAllParam() {
-    const boolColumns = this.getBoolColumns();
-    if (boolColumns.length) {
-      return 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 Query(new MutatorPipe(this.entityClass), ...restPipes);
     } else {
-      return Query(GetPipe());
+      return Query(...restPipes);
     }
   }
   update(extras = {}) {
@@ -2205,7 +2421,7 @@ var RestfulFactory = class _RestfulFactory {
     ]);
   }
   updateParam() {
-    return Body(UpdatePipe());
+    return Body(OptionalDataPipe(), OmitPipe(this.fieldsInUpdateToOmit));
   }
   delete(extras = {}) {
     return MergeMethodDecorators([
@@ -2359,14 +2575,134 @@ 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`);
+    }
+  }
+);
 export {
   BlankCursorPaginationReturnMessageDto,
   BoolColumn,
-  CreatePipe,
   CrudBase,
   CrudService,
   CursorPaginationDto,
@@ -2375,7 +2711,14 @@ export {
   EnumColumn,
   FloatColumn,
   GenericCursorPaginationReturnMessageDto,
-  GetPipe,
+  GetMutator,
+  GetMutatorBool,
+  GetMutatorFloat,
+  GetMutatorFloatSeparated,
+  GetMutatorInt,
+  GetMutatorIntSeparated,
+  GetMutatorJson,
+  GetMutatorStringSeparated,
   IdBase,
   ImportDataBaseDto,
   ImportDataDto,
@@ -2386,10 +2729,15 @@ export {
   JsonColumn,
   NotChangeable,
   NotColumn,
+  NotCreatable,
   NotInResult,
   NotQueryable,
   NotWritable,
+  OmitPipe,
+  OptionalDataPipe,
   PageSettingsDto,
+  PickPipe,
+  QueryAnd,
   QueryColumn,
   QueryCondition,
   QueryEqual,
@@ -2397,16 +2745,24 @@ export {
   QueryFullText,
   QueryGreater,
   QueryGreaterEqual,
+  QueryIn,
+  QueryJsonbHas,
   QueryLess,
   QueryLessEqual,
   QueryLike,
+  QueryManual,
   QueryMatchBoolean,
   QueryMatchBooleanMySQL,
   QueryNotEqual,
+  QueryNotIn,
   QueryOperator,
+  QueryOr,
   QuerySearch,
+  QueryWrap,
+  QueryWrapInfo,
   Relation,
   RelationComputed,
+  RequireGetMutator,
   RestfulFactory,
   SimpleJsonColumn,
   StringColumn,
@@ -2414,7 +2770,6 @@ export {
   StringJsonColumn,
   TextColumn,
   TimeBase,
-  UpdatePipe,
   UuidColumn,
   applyQueryMatchBoolean,
   applyQueryMatchBooleanMySQL,
@@ -2422,7 +2777,11 @@ export {
   applyQueryPropertyLike,
   applyQueryPropertySearch,
   applyQueryPropertyZeroNullable,
+  createGetMutator,
+  createQueryArrayify,
   createQueryCondition,
-  createQueryOperator
+  createQueryOperator,
+  createQueryOperatorArrayify,
+  createQueryWrap
 };
 //# sourceMappingURL=index.mjs.map