nicot 1.1.22 → 1.1.24

package/dist/index.mjs

@@ -0,0 +1,2184 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp(target, key, result);
+  return result;
+};
+
+// index.ts
+export * from "nesties";
+
+// src/dto/import-entry.ts
+import { ApiProperty } from "@nestjs/swagger";
+import { Type } from "class-transformer";
+import { ValidateNested } from "class-validator";
+import {
+  getClassFromClassOrArray,
+  InsertField
+} from "nesties";
+var ImportEntryBaseDto = class {
+};
+__decorateClass([
+  ApiProperty({ description: "Import result", type: String })
+], ImportEntryBaseDto.prototype, "result", 2);
+function ImportEntryDto(type) {
+  return InsertField(
+    ImportEntryBaseDto,
+    {
+      entry: { type, options: { description: "Import entry" } }
+    },
+    `${getClassFromClassOrArray(type).name}ImportEntry`
+  );
+}
+var ImportDataBaseDto = class {
+};
+__decorateClass([
+  ValidateNested()
+], ImportDataBaseDto.prototype, "data", 2);
+function ImportDataDto(type) {
+  const dtoClass = InsertField(
+    ImportDataBaseDto,
+    {
+      data: { type: [type], options: { description: "Import data" } }
+    },
+    `${getClassFromClassOrArray(type).name}ImportData`
+  );
+  Type(() => type)(dtoClass.prototype, "data");
+  return dtoClass;
+}
+
+// src/dto/cursor-pagination.ts
+import {
+  IsInt as IsInt2,
+  IsNotEmpty,
+  IsOptional as IsOptional3,
+  IsPositive,
+  IsString as IsString2
+} from "class-validator";
+import { ApiProperty as ApiProperty3 } from "@nestjs/swagger";
+import {
+  BlankReturnMessageDto,
+  getClassFromClassOrArray as getClassFromClassOrArray3,
+  InsertField as InsertField2
+} from "nesties";
+
+// src/decorators/access.ts
+import { Expose } from "class-transformer";
+import { IsOptional } from "class-validator";
+
+// src/utility/metadata.ts
+import { MetadataSetter, Reflector } from "typed-reflector";
+var Metadata = new MetadataSetter();
+var reflector = new Reflector();
+function getSpecificFields(obj, type, filter = () => true) {
+  return reflector.getArray(`${type}Fields`, obj).filter((field) => {
+    const value = reflector.get(type, obj, field);
+    if (value == null) {
+      return false;
+    }
+    return filter(value, obj);
+  });
+}
+function getNotInResultFields(obj, keepEntityVersioningDates = false) {
+  return getSpecificFields(
+    obj,
+    "notInResult",
+    (meta) => !keepEntityVersioningDates || !meta.entityVersioningDate
+  );
+}
+
+// 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")
+]);
+var NotChangeable = () => MergePropertyDecorators([
+  Expose({ groups: ["r", "c"] }),
+  Metadata.set("notChangeable", true, "notChangeableFields")
+]);
+var NotQueryable = () => Metadata.set("notQueryable", true, "notQueryableFields");
+var NotInResult = (options = {}) => Metadata.set("notInResult", options, "notInResultFields");
+
+// src/decorators/property.ts
+import { ApiProperty as ApiProperty2 } from "@nestjs/swagger";
+import { MergePropertyDecorators as MergePropertyDecorators2 } from "nesties";
+import { Column, Index } from "typeorm";
+import {
+  IsDate,
+  IsEnum,
+  IsInt,
+  IsNumber,
+  IsOptional as IsOptional2,
+  IsString,
+  MaxLength,
+  Min,
+  ValidateNested as ValidateNested2
+} from "class-validator";
+import { Exclude, Transform, Type as Type2 } from "class-transformer";
+
+// src/utility/bigint.ts
+var BigintTransformer = class {
+  from(dbValue) {
+    if (dbValue == null) {
+      return dbValue;
+    }
+    return parseInt(dbValue);
+  }
+  to(entValue) {
+    return entValue;
+  }
+};
+
+// src/decorators/property.ts
+import { getClassFromClassOrArray as getClassFromClassOrArray2 } from "nesties";
+
+// src/utility/type-transformer.ts
+var TypeTransformer = class {
+  constructor(definition) {
+    this.definition = definition;
+  }
+  from(dbValue) {
+    if (!dbValue) {
+      return dbValue;
+    }
+    if (Array.isArray(this.definition)) {
+      return dbValue.map(
+        (value) => Object.assign(new this.definition[0](), value)
+      );
+    }
+    return Object.assign(new this.definition(), dbValue);
+  }
+  to(entValue) {
+    return entValue;
+  }
+};
+
+// src/decorators/property.ts
+function swaggerDecorator(options, injected = {}) {
+  return ApiProperty2({
+    default: options.default,
+    required: !!(options.required && options.default == null),
+    example: options.default,
+    description: options.description,
+    ...injected,
+    ...options.propertyExtras || {}
+  });
+}
+function validatorDecorator(options) {
+  const decs = [];
+  if (!options.required) {
+    decs.push(IsOptional2());
+  }
+  return MergePropertyDecorators2(decs);
+}
+function columnDecoratorOptions(options) {
+  return {
+    default: options.default,
+    nullable: !options.required && options.default == null,
+    comment: options.description,
+    ...options.columnExtras
+  };
+}
+var StringColumn = (length, options = {}) => {
+  return MergePropertyDecorators2([
+    Column("varchar", { length, ...columnDecoratorOptions(options) }),
+    IsString(),
+    MaxLength(length),
+    validatorDecorator(options),
+    swaggerDecorator(options, { type: String, maxLength: length })
+  ]);
+};
+var IntColumn = (type, options = {}) => {
+  const decs = [
+    Column(type, {
+      default: options.default,
+      unsigned: options.unsigned,
+      ...type === "bigint" ? { transformer: new BigintTransformer() } : {},
+      ...columnDecoratorOptions(options)
+    }),
+    IsInt(),
+    validatorDecorator(options),
+    swaggerDecorator(options, {
+      type: Number,
+      minimum: options.unsigned ? 0 : void 0
+    })
+  ];
+  if (options.unsigned) {
+    decs.push(Min(0));
+  }
+  return MergePropertyDecorators2(decs);
+};
+var FloatColumn = (type, options = {}) => {
+  const decs = [
+    Column(type, {
+      default: options.default,
+      unsigned: options.unsigned,
+      ...columnDecoratorOptions(options)
+    }),
+    IsNumber(),
+    validatorDecorator(options),
+    swaggerDecorator(options, {
+      type: Number,
+      minimum: options.unsigned ? 0 : void 0
+    })
+  ];
+  if (options.unsigned) {
+    decs.push(Min(0));
+  }
+  return MergePropertyDecorators2(decs);
+};
+var DateColumn = (options = {}) => {
+  return MergePropertyDecorators2([
+    Column("timestamp", columnDecoratorOptions(options)),
+    IsDate(),
+    Transform(
+      (v) => {
+        const value = v.value;
+        if (value == null || value instanceof Date) return value;
+        const timestampToDate = (t, isSeconds) => new Date(isSeconds ? t * 1e3 : t);
+        if (typeof value === "number") {
+          const isSeconds = !Number.isInteger(value) || value < 1e12;
+          return timestampToDate(value, isSeconds);
+        }
+        if (typeof value === "string" && /^\d+(\.\d+)?$/.test(value)) {
+          const isSeconds = value.includes(".") || parseFloat(value) < 1e12;
+          return timestampToDate(parseFloat(value), isSeconds);
+        }
+        return new Date(value);
+      },
+      {
+        toClassOnly: true
+      }
+    ),
+    validatorDecorator(options),
+    swaggerDecorator(options, { type: Date })
+  ]);
+};
+var EnumColumn = (targetEnum, options = {}) => {
+  return MergePropertyDecorators2([
+    Index(),
+    Column("enum", {
+      enum: targetEnum,
+      ...columnDecoratorOptions(options)
+    }),
+    IsEnum(targetEnum),
+    validatorDecorator(options),
+    swaggerDecorator(options, { enum: targetEnum })
+  ]);
+};
+var BoolColumn = (options = {}) => MergePropertyDecorators2([
+  Index(),
+  Transform((v) => {
+    const trueValues = ["true", "1", "yes", "on", true, 1];
+    const falseValues = ["false", "0", "no", "off", false, 0];
+    if (trueValues.indexOf(v.value) !== -1) return true;
+    if (falseValues.indexOf(v.value) !== -1) return false;
+    return void 0;
+  }),
+  Column("boolean", columnDecoratorOptions(options)),
+  validatorDecorator(options),
+  swaggerDecorator(options, { type: Boolean })
+]);
+var JsonColumn = (definition, options = {}) => {
+  const cl = getClassFromClassOrArray2(definition);
+  return MergePropertyDecorators2([
+    NotQueryable(),
+    Type2(() => cl),
+    ValidateNested2(),
+    Column("jsonb", {
+      ...columnDecoratorOptions(options),
+      transformer: new TypeTransformer(definition)
+    }),
+    validatorDecorator(options),
+    swaggerDecorator(options, { type: definition })
+  ]);
+};
+var NotColumn = (options = {}, specials = {}) => MergePropertyDecorators2([
+  Exclude(),
+  swaggerDecorator({
+    required: false,
+    ...options
+  }),
+  Metadata.set("notColumn", specials, "notColumnFields")
+]);
+var QueryColumn = (options = {}) => MergePropertyDecorators2([
+  NotWritable(),
+  NotInResult(),
+  swaggerDecorator({
+    required: false,
+    ...options
+  })
+]);
+var RelationComputed = (type) => (obj, propertyKey) => {
+  const fun = () => {
+    const designType = Reflect.getMetadata("design:type", obj, propertyKey);
+    const entityClass = type ? type() : designType;
+    return {
+      entityClass,
+      isArray: designType === Array
+    };
+  };
+  const dec = Metadata.set("relationComputed", fun, "relationComputedFields");
+  return dec(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({
+  transform: true,
+  transformOptions: { groups: ["r"], 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 = obj[field];
+    if (value === true || value === "true" || value === 1 || value === "1") {
+      qb.andWhere(`${entityName}.${field} = TRUE`);
+    }
+    if (value === false || value === "false" || value === 0 || value === "0") {
+      qb.andWhere(`${entityName}.${field} = FALSE`);
+    }
+  }
+);
+
+// src/decorators/query.ts
+import { MergePropertyDecorators as MergePropertyDecorators3 } from "nesties";
+
+// src/utility/unshift-order-by.ts
+var unshiftOrderBy = (qb, sort, order, nulls) => {
+  const currentOrderBys = Object.entries(qb.expressionMap.allOrderBys);
+  qb.orderBy(sort, order, nulls);
+  currentOrderBys.forEach(([key, value]) => {
+    if (typeof value === "string") {
+      qb.addOrderBy(key, value);
+    } else {
+      qb.addOrderBy(key, value.order, value.nulls);
+    }
+  });
+  return qb;
+};
+
+// src/utility/subject-registry.ts
+var subjectRegistry = /* @__PURE__ */ new WeakMap();
+var addSubject = (qb, select, alias) => {
+  let subjects = subjectRegistry.get(qb);
+  if (!subjects) {
+    subjects = {};
+    subjectRegistry.set(qb, subjects);
+  }
+  subjects[alias] = select;
+  return qb.addSelect(select, alias);
+};
+var getSubject = (qb, alias) => {
+  return subjectRegistry.get(qb)?.[alias];
+};
+
+// src/decorators/query.ts
+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 QueryOperator = (operator, 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]
+  });
+});
+var createQueryOperator = (operator) => (field) => QueryOperator(operator, field);
+var QueryGreater = createQueryOperator(">");
+var QueryGreaterEqual = createQueryOperator(">=");
+var QueryLess = createQueryOperator("<");
+var QueryLessEqual = createQueryOperator("<=");
+var QueryNotEqual = createQueryOperator("!=");
+var QueryFullText = (options = {}) => {
+  const configurationName = options.parser ? `nicot_parser_${options.parser}` : options.configuration || "english";
+  const tsQueryFunction = options.tsQueryFunction || "websearch_to_tsquery";
+  return MergePropertyDecorators3([
+    QueryCondition((obj, qb, entityName, key) => {
+      if (obj[key] == null) return;
+      const fieldName = key;
+      const typeormField = key;
+      const tsVectorStatement = `to_tsvector('${configurationName}', "${entityName}"."${fieldName}")`;
+      const tsQueryStatement = `${tsQueryFunction}('${configurationName}', :${typeormField})`;
+      qb.andWhere(`${tsVectorStatement} @@ ${tsQueryStatement}`, {
+        [typeormField]: obj[key]
+      });
+      if (options.orderBySimilarity) {
+        const rankVirtualField = `_fulltext_rank_${key}`;
+        addSubject(
+          qb,
+          `ts_rank(${tsVectorStatement}, ${tsQueryStatement})`,
+          rankVirtualField
+        );
+        unshiftOrderBy(qb, `"${rankVirtualField}"`, "DESC");
+      }
+    }),
+    Metadata.set(
+      "queryFullTextColumn",
+      {
+        ...options,
+        configuration: configurationName
+      },
+      "queryFullTextColumnFields"
+    )
+  ]);
+};
+
+// src/dto/cursor-pagination.ts
+var CursorPaginationDto = class {
+};
+__decorateClass([
+  NotWritable(),
+  IsNotEmpty(),
+  IsString2(),
+  IsOptional3(),
+  ApiProperty3({
+    description: "Pagination Cursor",
+    required: false,
+    type: String
+  }),
+  NotInResult()
+], CursorPaginationDto.prototype, "paginationCursor", 2);
+__decorateClass([
+  NotWritable(),
+  IsPositive(),
+  IsInt2(),
+  ApiProperty3({
+    description: "Records per page.",
+    required: false,
+    type: Number,
+    minimum: 1
+  }),
+  NotInResult()
+], CursorPaginationDto.prototype, "recordsPerPage", 2);
+var BlankCursorPaginationReturnMessageDto = class extends BlankReturnMessageDto {
+  constructor(statusCode, message, cursorResponse) {
+    super(statusCode, message);
+    this.nextCursor = cursorResponse.nextCursor;
+    this.previousCursor = cursorResponse.previousCursor;
+  }
+};
+__decorateClass([
+  ApiProperty3({
+    description: "Next Cursor",
+    required: false,
+    type: String
+  })
+], BlankCursorPaginationReturnMessageDto.prototype, "nextCursor", 2);
+__decorateClass([
+  ApiProperty3({
+    description: "Previous Cursor",
+    required: false,
+    type: String
+  })
+], BlankCursorPaginationReturnMessageDto.prototype, "previousCursor", 2);
+var GenericCursorPaginationReturnMessageDto = class extends BlankCursorPaginationReturnMessageDto {
+  constructor(statusCode, message, data, cursorResponse) {
+    super(statusCode, message, cursorResponse);
+    this.data = data;
+  }
+};
+function CursorPaginationReturnMessageDto(type) {
+  return InsertField2(
+    GenericCursorPaginationReturnMessageDto,
+    {
+      data: {
+        type: [type],
+        options: {
+          required: false,
+          description: "Return data."
+        }
+      }
+    },
+    `${getClassFromClassOrArray3(type).name}CursorPaginationReturnMessageDto`
+  );
+}
+
+// src/crud-base.ts
+import {
+  In
+} from "typeorm";
+
+// src/bases/time-base.ts
+import {
+  CreateDateColumn,
+  DeleteDateColumn,
+  UpdateDateColumn
+} from "typeorm";
+
+// src/bases/page-settings.ts
+import { IsInt as IsInt3, IsPositive as IsPositive2 } from "class-validator";
+import { ApiProperty as ApiProperty4 } from "@nestjs/swagger";
+var PageSettingsDto = class {
+  getActualPageSettings() {
+    return {
+      pageCount: this.getPageCount(),
+      recordsPerPage: this.getRecordsPerPage()
+    };
+  }
+  getPageCount() {
+    return parseInt(this.pageCount) || 1;
+  }
+  getRecordsPerPage() {
+    return parseInt(this.recordsPerPage) || 25;
+  }
+  getStartingFrom() {
+    return (this.getPageCount() - 1) * this.getRecordsPerPage();
+  }
+  applyPaginationQuery(qb) {
+    qb.take(this.getRecordsPerPage()).skip(this.getStartingFrom());
+  }
+  applyQuery(qb, entityName) {
+  }
+};
+__decorateClass([
+  NotWritable(),
+  IsPositive2(),
+  IsInt3(),
+  ApiProperty4({
+    description: "The nth page, starting with 1.",
+    required: false,
+    type: Number,
+    minimum: 1
+  }),
+  NotInResult()
+], PageSettingsDto.prototype, "pageCount", 2);
+__decorateClass([
+  NotWritable(),
+  IsPositive2(),
+  IsInt3(),
+  ApiProperty4({
+    description: "Records per page.",
+    required: false,
+    type: Number,
+    minimum: 1
+  }),
+  NotInResult()
+], PageSettingsDto.prototype, "recordsPerPage", 2);
+
+// src/bases/time-base.ts
+var TimeBase = class extends PageSettingsDto {
+  isValidInCreate() {
+    return;
+  }
+  // eslint-disable-next-line @typescript-eslint/no-empty-function
+  async beforeCreate() {
+  }
+  // eslint-disable-next-line @typescript-eslint/no-empty-function
+  async afterCreate() {
+  }
+  // eslint-disable-next-line @typescript-eslint/no-empty-function
+  async beforeGet() {
+  }
+  // eslint-disable-next-line @typescript-eslint/no-empty-function
+  async afterGet() {
+  }
+  isValidInUpdate() {
+    return;
+  }
+  // eslint-disable-next-line @typescript-eslint/no-empty-function
+  async beforeUpdate() {
+  }
+};
+__decorateClass([
+  CreateDateColumn({ select: false }),
+  NotColumn(),
+  NotInResult({ entityVersioningDate: true })
+], TimeBase.prototype, "createTime", 2);
+__decorateClass([
+  UpdateDateColumn({ select: false }),
+  NotColumn(),
+  NotInResult({ entityVersioningDate: true })
+], TimeBase.prototype, "updateTime", 2);
+__decorateClass([
+  DeleteDateColumn({ select: false }),
+  NotColumn(),
+  NotInResult({ entityVersioningDate: true })
+], TimeBase.prototype, "deleteTime", 2);
+
+// src/bases/id-base.ts
+import { Generated } from "typeorm";
+import { IsNotEmpty as IsNotEmpty2, IsString as IsString3 } from "class-validator";
+import { MergePropertyDecorators as MergePropertyDecorators4 } from "nesties";
+function IdBase(idOptions = {}) {
+  const cl = class IdBase extends TimeBase {
+    applyQuery(qb, entityName) {
+      super.applyQuery(qb, entityName);
+      if (!idOptions.noOrderById) {
+        qb.orderBy(`${entityName}.id`, "DESC");
+      }
+      applyQueryProperty(this, qb, entityName, "id");
+    }
+  };
+  const dec = MergePropertyDecorators4([
+    NotWritable(),
+    IntColumn("bigint", {
+      unsigned: true,
+      description: idOptions.description,
+      columnExtras: { nullable: false, primary: true }
+    }),
+    Reflect.metadata("design:type", Number),
+    Generated("increment")
+  ]);
+  dec(cl.prototype, "id");
+  return cl;
+}
+function StringIdBase(idOptions) {
+  const cl = class StringIdBase extends TimeBase {
+    applyQuery(qb, entityName) {
+      super.applyQuery(qb, entityName);
+      console.log("idbase order by");
+      qb.orderBy(`${entityName}.id`, "ASC");
+      applyQueryProperty(this, qb, entityName, "id");
+    }
+  };
+  const decs = [
+    StringColumn(idOptions.length || (idOptions.uuid ? 36 : 255), {
+      required: !idOptions.uuid,
+      description: idOptions.description,
+      columnExtras: { primary: true, nullable: false }
+    }),
+    Reflect.metadata("design:type", String),
+    ...idOptions.uuid ? [Generated("uuid"), NotWritable()] : [IsString3(), IsNotEmpty2(), NotChangeable()]
+  ];
+  const dec = MergePropertyDecorators4(decs);
+  dec(cl.prototype, "id");
+  return cl;
+}
+
+// src/crud-base.ts
+import { ConsoleLogger } from "@nestjs/common";
+import { camelCase } from "typeorm/util/StringUtils";
+import _3, { omit } from "lodash";
+import {
+  BlankReturnMessageDto as BlankReturnMessageDto2,
+  PaginatedReturnMessageDto,
+  ReturnMessageDto
+} from "nesties";
+
+// src/utility/get-typeorm-relations.ts
+import { getMetadataArgsStorage } from "typeorm";
+import _ from "lodash";
+function getTypeormRelations(cl) {
+  const relations = getMetadataArgsStorage().relations.filter(
+    (r) => r.target === cl
+  );
+  const typeormRelations = relations.map((relation) => {
+    const isArray = relation.relationType.endsWith("-many");
+    const relationClassFactory = relation.type;
+    let propertyClass;
+    if (typeof relationClassFactory === "function") {
+      const relationClass = relationClassFactory();
+      if (typeof relationClass === "function") {
+        propertyClass = relationClass;
+      }
+    }
+    if (!propertyClass) {
+      propertyClass = Reflect.getMetadata(
+        "design:type",
+        cl.prototype,
+        relation.propertyName
+      );
+    }
+    return {
+      isArray,
+      propertyClass,
+      propertyName: relation.propertyName,
+      computed: false
+    };
+  });
+  const computedRelations = getSpecificFields(cl, "relationComputed").map(
+    (field) => {
+      const meta = reflector.get("relationComputed", cl, field);
+      const res = meta();
+      return {
+        isArray: res.isArray,
+        propertyClass: res.entityClass,
+        propertyName: field,
+        computed: true
+      };
+    }
+  );
+  return _.uniqBy(
+    [...typeormRelations, ...computedRelations],
+    // Merge typeorm relations and computed relations
+    (r) => r.propertyName
+  );
+}
+
+// src/utility/cursor-pagination-utils.ts
+import { Brackets } from "typeorm";
+import _2 from "lodash";
+import SJSON from "superjson";
+
+// src/utility/filter-relations.ts
+var extractRelationName = (relation) => {
+  if (typeof relation === "string") {
+    return relation;
+  } else {
+    return relation.name;
+  }
+};
+var typeormRelationsCache = /* @__PURE__ */ new Map();
+var fetchTypeormRelations = (cl) => {
+  if (typeormRelationsCache.has(cl)) {
+    return typeormRelationsCache.get(cl);
+  }
+  const relations = getTypeormRelations(cl);
+  const map = Object.fromEntries(
+    relations.map((r) => [r.propertyName, r])
+  );
+  typeormRelationsCache.set(cl, map);
+  return map;
+};
+var filterRelations = (cl, relations, cond = () => true) => {
+  return relations?.filter((r) => {
+    const relationName = extractRelationName(r);
+    const checkLevel = (entityClass, name) => {
+      const [currentLevel, ...nextLevel] = name.split(".");
+      const relation = fetchTypeormRelations(entityClass)?.[currentLevel];
+      if (!relation) {
+        throw new Error(
+          `Relation ${currentLevel} not found in ${entityClass.name} (Reading ${relationName} in ${cl.name})`
+        );
+      }
+      if (relation.computed) return false;
+      if (!nextLevel.length) return true;
+      return checkLevel(relation.propertyClass, nextLevel.join("."));
+    };
+    return checkLevel(cl, relationName);
+  }) || [];
+};
+var queryColumnOptionsFromAlias = (qb, cl, rootAlias, alias) => {
+  const [field, key] = alias.split(".");
+  if (field === rootAlias) {
+    return {
+      relations: [],
+      column: qb.connection.getMetadata(cl)?.findColumnWithPropertyName(key)
+    };
+  }
+  const relationLevels = field.split("_");
+  let currentClass = cl;
+  const relations = [];
+  while (relationLevels.length) {
+    const f = relationLevels.shift();
+    const relation = fetchTypeormRelations(currentClass)?.[f];
+    if (!relation || relation.computed) {
+      return;
+    }
+    relations.push(relation);
+    currentClass = relation.propertyClass;
+  }
+  return {
+    relations,
+    column: qb.connection.getMetadata(currentClass)?.findColumnWithPropertyName(key)
+  };
+};
+
+// src/utility/cursor-pagination-utils.ts
+function getValueFromOrderBy(orderBy, reversed = false) {
+  if (reversed) {
+    const value = getValueFromOrderBy(orderBy, false);
+    return value === "ASC" ? "DESC" : "ASC";
+  }
+  return typeof orderBy === "string" ? orderBy : orderBy.order;
+}
+function getNullsFromOrderBy(orderBy, reversed = false) {
+  if (reversed) {
+    const value = getNullsFromOrderBy(orderBy, false);
+    return value === "NULLS FIRST" ? "NULLS LAST" : "NULLS FIRST";
+  }
+  const nulls = typeof orderBy === "string" ? void 0 : orderBy.nulls;
+  if (!nulls) {
+    const value = getValueFromOrderBy(orderBy);
+    return value === "ASC" ? "NULLS FIRST" : "NULLS LAST";
+  }
+  return nulls;
+}
+function getOperator(orderBy) {
+  const value = getValueFromOrderBy(orderBy);
+  return value === "ASC" ? ">" : "<";
+}
+function getReversedTypeormOrderBy(orderBy) {
+  if (typeof orderBy === "string") {
+    return {
+      order: orderBy === "ASC" ? "DESC" : "ASC",
+      nulls: void 0
+    };
+  }
+  return {
+    order: orderBy.order === "ASC" ? "DESC" : "ASC",
+    nulls: orderBy.nulls ? orderBy.nulls === "NULLS FIRST" ? "NULLS LAST" : "NULLS FIRST" : void 0
+  };
+}
+function reverseQueryOrderBy(qb) {
+  const orderBys = getTypeormOrderBy(qb);
+  orderBys.forEach(({ key, direction }, i) => {
+    const reversed = getReversedTypeormOrderBy(direction);
+    if (i === 0) {
+      qb.orderBy(key, reversed.order, reversed.nulls);
+    } else {
+      qb.addOrderBy(key, reversed.order, reversed.nulls);
+    }
+  });
+}
+function getTypeormOrderBy(qb) {
+  const orderBy = qb.expressionMap.allOrderBys;
+  const orderByEntrys = Object.entries(orderBy);
+  return orderByEntrys.map(([key, value]) => ({
+    key,
+    direction: value
+  }));
+}
+function extractValueFromOrderByKey(obj, key, entityAliasName) {
+  const getField = (obj2, key2) => {
+    const value2 = obj2[key2];
+    if (value2 == null) return value2;
+    if (Array.isArray(value2)) {
+      return void 0;
+    }
+    return value2;
+  };
+  const [alias, field] = key.split(".");
+  if (alias === entityAliasName) {
+    return getField(obj, field);
+  }
+  const aliasParts = alias.split("_");
+  if (aliasParts.length === 1) {
+    const value2 = getField(obj, alias);
+    if (value2 == null) return value2;
+    return getField(value2, field);
+  }
+  const value = getField(obj, aliasParts[0]);
+  if (!value == null) return value;
+  return extractValueFromOrderByKey(
+    value,
+    `${aliasParts.slice(1).join("_")}.${field}`
+  );
+}
+function encodeBase64Url(str) {
+  return Buffer.from(str).toString("base64").replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+function decodeBase64Url(str) {
+  str = str.replace(/-/g, "+").replace(/_/g, "/");
+  while (str.length % 4) str += "=";
+  return Buffer.from(str, "base64").toString();
+}
+async function getPaginatedResult(qb, entityClass, entityAliasName, take, cursor) {
+  const orderBys = getTypeormOrderBy(qb);
+  qb.take(take + 1);
+  let type = "next";
+  if (cursor) {
+    const data2 = SJSON.parse(decodeBase64Url(cursor));
+    type = data2.type;
+    const keys = Object.keys(data2.payload).filter(
+      (k) => qb.expressionMap.orderBys[k]
+    );
+    if (keys.length) {
+      const staircasedKeys = keys.map(
+        (key, i) => _2.range(i + 1).map((j) => keys[j])
+      );
+      const cursorKey = (key) => `_cursor_${key.replace(/\./g, "__").replace(/"/g, "")}`;
+      const expressionMatrix = staircasedKeys.map(
+        (keys2) => keys2.map((key, j) => {
+          const paramKey = cursorKey(key);
+          const cursorValue = data2.payload[key];
+          const orderBy = qb.expressionMap.orderBys[key];
+          const reversed = data2.type === "prev";
+          const order = getValueFromOrderBy(orderBy, reversed);
+          const nulls = getNullsFromOrderBy(orderBy, reversed);
+          const isLast = j === keys2.length - 1;
+          const subject = key.includes('"') ? getSubject(qb, key.replace(/"/g, "")) : key;
+          const mayBeNullAtEnd = () => {
+            const res = nulls === "NULLS LAST" && order === "ASC" || nulls === "NULLS FIRST" && order === "DESC";
+            if (reversed) {
+              return !res;
+            }
+            return res;
+          };
+          if (cursorValue == null) {
+            if (isLast) {
+              if (mayBeNullAtEnd()) {
+                return "__never__";
+              } else {
+                return `${subject} IS NOT NULL`;
+              }
+            } else {
+              return `${subject} IS NULL`;
+            }
+          } else {
+            if (isLast) {
+              const expr = `${subject} ${getOperator(order)} :${paramKey}`;
+              if (mayBeNullAtEnd() && queryColumnOptionsFromAlias(
+                qb,
+                entityClass,
+                entityAliasName,
+                key
+              )?.column?.isNullable) {
+                return `(${expr} OR ${subject} IS NULL)`;
+              }
+              return expr;
+            } else {
+              return `${subject} = :${paramKey}`;
+            }
+          }
+        })
+      ).filter((s) => !s.includes("__never__"));
+      if (expressionMatrix.length) {
+        qb.andWhere(
+          new Brackets((sqb) => {
+            const levelToBrackets = (level) => new Brackets((qb2) => {
+              level.forEach((expr, i) => {
+                if (i === 0) {
+                  qb2.where(expr);
+                } else {
+                  qb2.andWhere(expr);
+                }
+              });
+            });
+            const [first, ...rest] = expressionMatrix;
+            sqb.where(levelToBrackets(first));
+            rest.forEach((level) => sqb.orWhere(levelToBrackets(level)));
+          })
+        ).setParameters(
+          Object.fromEntries(
+            Object.entries(data2.payload).filter(([k, v]) => qb.expressionMap.orderBys[k] && v != null).map(([k, v]) => [cursorKey(k), v])
+          )
+        );
+      }
+    }
+    if (data2.type === "prev") {
+      reverseQueryOrderBy(qb);
+    }
+  }
+  const { raw, entities: data } = await qb.getRawAndEntities();
+  const rawMapById = /* @__PURE__ */ new Map();
+  const getRawFromEntity = (entity) => {
+    const isNumberId = typeof entity.id === "number";
+    const id = entity.id;
+    if (rawMapById.has(id)) {
+      return rawMapById.get(id);
+    }
+    return raw.find((r) => {
+      let id2 = r[`${entityAliasName}_id`];
+      if (isNumberId) {
+        id2 = Number(id2);
+        if (isNaN(id2)) return false;
+      }
+      if (id2 == null) return false;
+      rawMapById[id2] = r;
+      return id2 === entity.id;
+    });
+  };
+  const enough = data.length > take;
+  const hasNext = enough || type === "prev";
+  const hasPrev = cursor && (enough || type === "next");
+  if (enough) {
+    data.pop();
+  }
+  if (type === "prev") {
+    data.reverse();
+  }
+  const generateCursor = (type2, data2) => {
+    const targetObject = type2 === "prev" ? data2[0] : data2[data2.length - 1];
+    const payload = Object.fromEntries(
+      orderBys.map(({ key }) => {
+        const value = !key.includes(".") || key.includes('"') ? getRawFromEntity(targetObject)?.[key.replace(/"/g, "")] : extractValueFromOrderByKey(targetObject, key, entityAliasName);
+        return [key, value];
+      }).filter((s) => s[1] !== void 0)
+    );
+    return encodeBase64Url(SJSON.stringify({ type: type2, payload }));
+  };
+  return {
+    data,
+    paginatedResult: {
+      nextCursor: hasNext ? generateCursor("next", data) : void 0,
+      previousCursor: hasPrev ? generateCursor("prev", data) : void 0
+    }
+  };
+}
+
+// src/crud-base.ts
+import PQueue from "p-queue";
+var Relation = (name, options = {}) => {
+  return { name, inner: false, ...options };
+};
+var Inner = (name, options = {}) => {
+  return Relation(name, { inner: true, ...options });
+};
+var loadedParsers = /* @__PURE__ */ new Set();
+var loadFullTextQueue = new PQueue({
+  concurrency: 1
+});
+var CrudBase = class {
+  constructor(entityClass, repo, crudOptions) {
+    this.entityClass = entityClass;
+    this.repo = repo;
+    this.crudOptions = crudOptions;
+    this.entityName = this.entityClass.name;
+    this.entityReturnMessageDto = ReturnMessageDto(this.entityClass);
+    this.importEntryDto = ImportEntryDto(this.entityClass);
+    this.importReturnMessageDto = ReturnMessageDto([this.importEntryDto]);
+    this.entityPaginatedReturnMessageDto = PaginatedReturnMessageDto(
+      this.entityClass
+    );
+    this.entityCursorPaginatedReturnMessageDto = CursorPaginationReturnMessageDto(this.entityClass);
+    this.entityRelations = filterRelations(
+      this.entityClass,
+      this.crudOptions.relations,
+      (r) => !r.computed
+    );
+    this.extraGetQuery = this.crudOptions.extraGetQuery || ((qb) => {
+    });
+    this.log = new ConsoleLogger(`${this.entityClass.name}Service`);
+    this._typeormRelations = getTypeormRelations(this.entityClass);
+  }
+  _cleanEntityNotInResultFields(ent) {
+    const visited = /* @__PURE__ */ new Set();
+    const runSingleObject = (o, cl) => {
+      if (visited.has(o)) {
+        return o;
+      }
+      const fields = getNotInResultFields(
+        cl,
+        this.crudOptions.keepEntityVersioningDates
+      );
+      for (const field of fields) {
+        delete o[field];
+      }
+      visited.add(o);
+      for (const relation of this._typeormRelations) {
+        const propertyName = relation.propertyName;
+        if (o[propertyName]) {
+          if (Array.isArray(o[propertyName])) {
+            o[propertyName] = o[propertyName].map(
+              (r) => runSingleObject(r, relation.propertyClass)
+            );
+          } else {
+            o[propertyName] = runSingleObject(
+              o[propertyName],
+              relation.propertyClass
+            );
+          }
+        }
+      }
+      return o;
+    };
+    return runSingleObject(ent, this.entityClass);
+  }
+  cleanEntityNotInResultFields(ents) {
+    if (Array.isArray(ents)) {
+      return ents.map((ent) => this._cleanEntityNotInResultFields(ent));
+    } else {
+      return this._cleanEntityNotInResultFields(ents);
+    }
+  }
+  async _batchCreate(ents, beforeCreate, skipErrors = false) {
+    const entsWithId = ents.filter((ent) => ent.id != null);
+    const result = await this.repo.manager.transaction(async (mdb) => {
+      let skipped = [];
+      const repo = mdb.getRepository(this.entityClass);
+      let entsToSave = ents;
+      if (entsWithId.length) {
+        const entIds = entsWithId.map((ent) => ent.id);
+        const entIdChunks = _3.chunk(entIds, 65535);
+        const existingEnts = (await Promise.all(
+          entIdChunks.map(
+            (chunk) => repo.find({
+              // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+              // @ts-ignore
+              where: {
+                id: In(chunk)
+              },
+              select: this.crudOptions.createOrUpdate ? void 0 : ["id", "deleteTime"],
+              withDeleted: true
+            })
+          )
+        )).flat();
+        if (existingEnts.length) {
+          const existingEntsWithoutDeleteTime = existingEnts.filter(
+            (ent) => ent.deleteTime == null
+          );
+          const existingEntsWithDeleteTime = existingEnts.filter(
+            (ent) => ent.deleteTime != null
+          );
+          if (existingEntsWithoutDeleteTime.length) {
+            if (this.crudOptions.createOrUpdate) {
+              const existingIdMap = /* @__PURE__ */ new Map();
+              existingEntsWithoutDeleteTime.forEach((ent) => {
+                existingIdMap.set(ent.id, ent);
+              });
+              entsToSave = [];
+              for (const ent of ents) {
+                if (existingIdMap.has(ent.id)) {
+                  const existingEnt = existingIdMap.get(ent.id);
+                  Object.assign(existingEnt, ent);
+                  entsToSave.push(existingEnt);
+                } else {
+                  entsToSave.push(ent);
+                }
+              }
+            } else {
+              if (!skipErrors) {
+                throw new BlankReturnMessageDto2(
+                  404,
+                  `${this.entityName} ID ${existingEntsWithoutDeleteTime.join(
+                    ","
+                  )} already exists`
+                ).toException();
+              }
+              const existingEntsWithoutDeleteTimeIdSet = new Set(
+                existingEntsWithoutDeleteTime.map((e) => e.id)
+              );
+              const skippedEnts = ents.filter(
+                (ent) => existingEntsWithoutDeleteTimeIdSet.has(ent.id)
+              );
+              skipped = skippedEnts.map((ent) => ({
+                result: "Already exists",
+                entry: ent
+              }));
+              const skippedEntsSet = new Set(skippedEnts);
+              entsToSave = ents.filter((ent) => !skippedEntsSet.has(ent));
+            }
+          }
+          if (existingEntsWithDeleteTime.length) {
+            await repo.delete(
+              existingEntsWithDeleteTime.map((ent) => ent.id)
+            );
+          }
+        }
+      }
+      if (beforeCreate) {
+        await beforeCreate(repo);
+      }
+      try {
+        const entChunksToSave = _3.chunk(
+          entsToSave,
+          Math.floor(
+            65535 / Math.max(1, Object.keys(entsToSave[0] || {}).length)
+          )
+        );
+        let results = [];
+        for (const entChunk of entChunksToSave) {
+          const savedChunk = await repo.save(entChunk);
+          results = results.concat(savedChunk);
+        }
+        return {
+          results,
+          skipped
+        };
+      } catch (e) {
+        this.log.error(
+          `Failed to create entity ${JSON.stringify(
+            entsToSave
+          )}: ${e.toString()}`
+        );
+        throw new BlankReturnMessageDto2(500, "Internal error").toException();
+      }
+    });
+    return result;
+  }
+  async create(_ent, beforeCreate) {
+    if (!_ent) {
+      throw new BlankReturnMessageDto2(400, "Invalid entity").toException();
+    }
+    let ent = new this.entityClass();
+    Object.assign(
+      ent,
+      omit(_ent, ...this._typeormRelations.map((r) => r.propertyName))
+    );
+    const invalidReason = ent.isValidInCreate();
+    if (invalidReason) {
+      throw new BlankReturnMessageDto2(400, invalidReason).toException();
+    }
+    const savedEnt = await this.repo.manager.transaction(async (mdb) => {
+      const repo = mdb.getRepository(this.entityClass);
+      if (ent.id != null) {
+        const existingEnt = await repo.findOne({
+          where: { id: ent.id },
+          select: this.crudOptions.createOrUpdate ? void 0 : ["id", "deleteTime"],
+          withDeleted: true
+        });
+        if (existingEnt) {
+          if (existingEnt.deleteTime) {
+            await repo.delete(existingEnt.id);
+          } else if (this.crudOptions.createOrUpdate) {
+            Object.assign(existingEnt, ent);
+            ent = existingEnt;
+          } else {
+            throw new BlankReturnMessageDto2(
+              404,
+              `${this.entityName} ID ${ent.id} already exists`
+            ).toException();
+          }
+        }
+      }
+      if (beforeCreate) {
+        await beforeCreate(repo);
+      }
+      await ent.beforeCreate?.();
+      try {
+        const savedEnt2 = await repo.save(ent);
+        await savedEnt2.afterCreate?.();
+        return this.cleanEntityNotInResultFields(savedEnt2);
+      } catch (e) {
+        this.log.error(
+          `Failed to create entity ${JSON.stringify(ent)}: ${e.toString()}`
+        );
+        throw new BlankReturnMessageDto2(500, "Internal error").toException();
+      }
+    });
+    return new this.entityReturnMessageDto(200, "success", savedEnt);
+  }
+  get entityAliasName() {
+    return camelCase(this.entityName);
+  }
+  _applyQueryRelation(qb, relation) {
+    const { name } = relation;
+    const relationUnit = name.split(".");
+    const base = relationUnit.length === 1 ? this.entityAliasName : relationUnit.slice(0, relationUnit.length - 1).join("_");
+    const property = relationUnit[relationUnit.length - 1];
+    const properyAlias = relationUnit.join("_");
+    const methodName = relation.inner ? "innerJoin" : "leftJoin";
+    if (!relation.noSelect) {
+      qb.addSelect(properyAlias);
+    }
+    qb[methodName](
+      `${base}.${property}`,
+      properyAlias,
+      relation.extraCondition || void 0,
+      relation.extraConditionFields || void 0
+    );
+  }
+  _applyQueryRelations(qb) {
+    for (const relation of this.entityRelations) {
+      if (typeof relation === "string") {
+        this._applyQueryRelation(qb, { name: relation });
+      } else {
+        this._applyQueryRelation(qb, relation);
+      }
+    }
+  }
+  _applyQueryFilters(qb, ent) {
+    const queryFields = reflector.getArray(
+      "queryConditionFields",
+      this.entityClass
+    );
+    for (const field of queryFields) {
+      const condition = reflector.get(
+        "queryCondition",
+        this.entityClass,
+        field
+      );
+      if (condition) {
+        condition(ent, qb, this.entityAliasName, field);
+      }
+    }
+  }
+  queryBuilder() {
+    return this.repo.createQueryBuilder(this.entityAliasName);
+  }
+  async findOne(id, extraQuery = () => {
+  }) {
+    const query = this.queryBuilder().where(`${this.entityAliasName}.id = :id`, { id }).take(1);
+    this._applyQueryRelations(query);
+    this.extraGetQuery(query);
+    extraQuery(query);
+    query.take(1);
+    let ent;
+    try {
+      ent = await query.getOne();
+    } catch (e) {
+      const [sql, params] = query.getQueryAndParameters();
+      this.log.error(
+        `Failed to read entity ID ${id} with SQL ${sql} param ${params.join(
+          ","
+        )}: ${e.toString()}`
+      );
+      throw new BlankReturnMessageDto2(500, "Internal error").toException();
+    }
+    if (!ent) {
+      throw new BlankReturnMessageDto2(
+        404,
+        `${this.entityName} ID ${id} not found.`
+      ).toException();
+    }
+    await ent.afterGet?.();
+    return new this.entityReturnMessageDto(
+      200,
+      "success",
+      this.cleanEntityNotInResultFields(ent)
+    );
+  }
+  async _preFindAll(ent, extraQuery = () => {
+  }) {
+    const query = this.queryBuilder().where("1 = 1");
+    const newEnt = new this.entityClass();
+    if (ent) {
+      Object.assign(newEnt, ent);
+      await newEnt?.beforeGet?.();
+      newEnt.applyQuery(query, this.entityAliasName);
+    }
+    this._applyQueryRelations(query);
+    this._applyQueryFilters(query, newEnt);
+    const pageSettings = newEnt instanceof PageSettingsDto ? newEnt : Object.assign(new PageSettingsDto(), newEnt);
+    this.extraGetQuery(query);
+    extraQuery(query);
+    return { query, newEnt, pageSettings };
+  }
+  async findAll(ent, extraQuery = () => {
+  }) {
+    const { query, pageSettings } = await this._preFindAll(ent, extraQuery);
+    pageSettings.applyPaginationQuery(query);
+    try {
+      const [data, count] = await query.getManyAndCount();
+      await Promise.all(data.map((ent2) => ent2.afterGet?.()));
+      return new this.entityPaginatedReturnMessageDto(
+        200,
+        "success",
+        this.cleanEntityNotInResultFields(data),
+        count,
+        pageSettings.getActualPageSettings()
+      );
+    } catch (e) {
+      const [sql, params] = query.getQueryAndParameters();
+      this.log.error(
+        `Failed to read entity cond ${JSON.stringify(
+          ent
+        )} with SQL ${sql} param ${params.join(",")}: ${e.toString()}`
+      );
+      throw new BlankReturnMessageDto2(500, "Internal error").toException();
+    }
+  }
+  async findAllCursorPaginated(ent, extraQuery = () => {
+  }) {
+    const { query, pageSettings } = await this._preFindAll(ent, extraQuery);
+    try {
+      const { data, paginatedResult } = await getPaginatedResult(
+        query,
+        this.entityClass,
+        this.entityAliasName,
+        pageSettings.getRecordsPerPage(),
+        ent.paginationCursor
+      );
+      await Promise.all(data.map((ent2) => ent2.afterGet?.()));
+      return new this.entityCursorPaginatedReturnMessageDto(
+        200,
+        "success",
+        this.cleanEntityNotInResultFields(data),
+        paginatedResult
+      );
+    } catch (e) {
+      const [sql, params] = query.getQueryAndParameters();
+      this.log.error(
+        `Failed to read entity cond ${JSON.stringify(
+          ent
+        )} with SQL ${sql} param ${params.join(",")}: ${e.toString()}`
+      );
+      throw new BlankReturnMessageDto2(500, "Internal error").toException();
+    }
+  }
+  async update(id, entPart, cond = {}) {
+    let result;
+    const ent = new this.entityClass();
+    Object.assign(ent, entPart);
+    const invalidReason = ent.isValidInUpdate();
+    if (invalidReason) {
+      throw new BlankReturnMessageDto2(400, invalidReason).toException();
+    }
+    await ent.beforeUpdate?.();
+    try {
+      result = await this.repo.update(
+        {
+          id,
+          ...cond
+        },
+        ent
+      );
+    } catch (e) {
+      this.log.error(
+        `Failed to update entity ID ${id} to ${JSON.stringify(
+          entPart
+        )}: ${e.toString()}`
+      );
+      throw new BlankReturnMessageDto2(500, "Internal error").toException();
+    }
+    if (!result.affected) {
+      throw new BlankReturnMessageDto2(
+        404,
+        `${this.entityName} ID ${id} not found.`
+      ).toException();
+    }
+    return new BlankReturnMessageDto2(200, "success");
+  }
+  async delete(id, cond = {}) {
+    let result;
+    const searchCond = {
+      id,
+      ...cond
+    };
+    try {
+      result = await (this.crudOptions.hardDelete || !this.repo.manager.connection.getMetadata(this.entityClass).deleteDateColumn ? this.repo.delete(searchCond) : this.repo.softDelete(searchCond));
+    } catch (e) {
+      this.log.error(`Failed to delete entity ID ${id}: ${e.toString()}`);
+      throw new BlankReturnMessageDto2(500, "Internal error").toException();
+    }
+    if (!result.affected) {
+      throw new BlankReturnMessageDto2(
+        404,
+        `${this.entityName} ID ${id} not found.`
+      ).toException();
+    }
+    return new BlankReturnMessageDto2(200, "success");
+  }
+  async importEntities(_ents, extraChecking) {
+    const ents = _ents.map((ent) => {
+      const newEnt = new this.entityClass();
+      Object.assign(
+        newEnt,
+        omit(ent, ...this._typeormRelations.map((r) => r.propertyName))
+      );
+      return newEnt;
+    });
+    const invalidResults = _3.compact(
+      await Promise.all(
+        ents.map(async (ent) => {
+          const reason = ent.isValidInCreate();
+          if (reason) {
+            return { entry: ent, result: reason };
+          }
+          if (extraChecking) {
+            const reason2 = await extraChecking(ent);
+            if (reason2) {
+              return { entry: ent, result: reason2 };
+            }
+          }
+        })
+      )
+    );
+    const remainingEnts = ents.filter(
+      (ent) => !invalidResults.find((result) => result.entry === ent)
+    );
+    await Promise.all(remainingEnts.map((ent) => ent.beforeCreate?.()));
+    const data = await this._batchCreate(remainingEnts, void 0, true);
+    await Promise.all(data.results.map((e) => e.afterCreate?.()));
+    const results = [
+      ...invalidResults,
+      ...data.skipped,
+      ...data.results.map((e) => ({ entry: e, result: "OK" }))
+    ];
+    return new this.importReturnMessageDto(
+      200,
+      "success",
+      results.map((r) => {
+        const entry = new this.importEntryDto();
+        Object.assign(entry, r);
+        entry.entry = this.cleanEntityNotInResultFields(r.entry);
+        return entry;
+      })
+    );
+  }
+  async exists(id) {
+    const ent = await this.repo.findOne({ where: { id }, select: ["id"] });
+    return !!ent;
+  }
+  async _loadFullTextIndex() {
+    const fields = reflector.getArray(
+      "queryFullTextColumnFields",
+      this.entityClass
+    );
+    const metadata = this.repo.metadata;
+    const tableName = metadata.tableName;
+    const sqls = [];
+    for (const field of fields) {
+      const options = reflector.get(
+        "queryFullTextColumn",
+        this.entityClass,
+        field
+      );
+      if (!options) continue;
+      const configurationName = options.configuration;
+      const parser = options.parser;
+      if (parser && !loadedParsers.has(parser)) {
+        loadedParsers.add(parser);
+        sqls.push(
+          `CREATE EXTENSION IF NOT EXISTS ${parser};`,
+          `DROP TEXT SEARCH CONFIGURATION IF EXISTS ${configurationName};`,
+          `CREATE TEXT SEARCH CONFIGURATION ${configurationName} (PARSER = ${parser});`,
+          `ALTER TEXT SEARCH CONFIGURATION ${configurationName} ADD MAPPING FOR n, v, a, i, e, l WITH simple;`
+        );
+      }
+      const indexName = `idx_fulltext_${this.entityName}_${field}`;
+      sqls.push(
+        `CREATE INDEX IF NOT EXISTS "${indexName}" ON "${tableName}" USING GIN (to_tsvector('${configurationName}', "${field}"));`
+      );
+    }
+    if (sqls.length) {
+      await this.repo.manager.query(sqls.join("\n"));
+    }
+  }
+  async onModuleInit() {
+    await loadFullTextQueue.add(() => this._loadFullTextIndex());
+  }
+};
+function CrudService(entityClass, crudOptions = {}) {
+  return class CrudServiceImpl extends CrudBase {
+    constructor(repo) {
+      super(entityClass, repo, crudOptions);
+    }
+  };
+}
+
+// src/restful.ts
+import {
+  Body,
+  Delete,
+  Get,
+  HttpCode,
+  Param,
+  ParseIntPipe,
+  Patch,
+  Post,
+  Query
+} from "@nestjs/common";
+import {
+  BlankReturnMessageDto as BlankReturnMessageDto3,
+  MergeMethodDecorators,
+  PaginatedReturnMessageDto as PaginatedReturnMessageDto2,
+  ReturnMessageDto as ReturnMessageDto2
+} from "nesties";
+import {
+  ApiBadRequestResponse,
+  ApiBody,
+  ApiInternalServerErrorResponse,
+  ApiNotFoundResponse,
+  ApiOkResponse,
+  ApiOperation,
+  ApiParam,
+  ApiProperty as ApiProperty5,
+  IntersectionType,
+  OmitType as OmitType2,
+  PartialType
+} from "@nestjs/swagger";
+import _4, { upperFirst } from "lodash";
+
+// src/utility/rename-class.ts
+function RenameClass(cls, name) {
+  Object.defineProperty(cls, "name", { value: name });
+  return cls;
+}
+
+// src/restful.ts
+import { DECORATORS } from "@nestjs/swagger/dist/constants";
+
+// src/bases/base-restful-controller.ts
+var RestfulMethods = [
+  "findOne",
+  "findAll",
+  "create",
+  "update",
+  "delete",
+  "import"
+];
+var BaseRestfulController = class {
+  constructor(serviceOrRepo, _options = {}) {
+    this._options = _options;
+    if (serviceOrRepo instanceof CrudBase) {
+      this.service = serviceOrRepo;
+    } else {
+      const crudServiceClass = CrudService(this._options.entityClass, {
+        relations: this._options.relations
+      });
+      this.service = new crudServiceClass(serviceOrRepo);
+    }
+  }
+  findOne(id) {
+    return this.service.findOne(id);
+  }
+  findAll(dto) {
+    if (this._options.paginateType === "cursor") {
+      return this.service.findAllCursorPaginated(dto);
+    }
+    if (this._options.paginateType === "offset") {
+      return this.service.findAll(dto);
+    }
+    dto["recordsPerPage"] ??= 99999;
+    return this.service.findAll(dto);
+  }
+  create(dto) {
+    return this.service.create(dto);
+  }
+  update(id, dto) {
+    return this.service.update(id, dto);
+  }
+  delete(id) {
+    return this.service.delete(id);
+  }
+  import(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";
+var OmitTypeExclude = (cl, keys) => {
+  const omitted = OmitType(cl, keys);
+  for (const key of keys) {
+    Exclude2()(omitted.prototype, key);
+  }
+  return omitted;
+};
+
+// 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 {
+  constructor(entityClass, options = {}, __resolveVisited = /* @__PURE__ */ new Map()) {
+    this.entityClass = entityClass;
+    this.options = options;
+    this.__resolveVisited = __resolveVisited;
+    this.fieldsToOmit = _4.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")
+      ),
+      `Create${this.entityClass.name}Dto`
+    );
+    this.importDto = ImportDataDto(this.createDto);
+    this.findAllDto = RenameClass(
+      PartialType(
+        OmitTypeExclude(
+          this.entityClass instanceof PageSettingsDto ? this.basicInputDto : IntersectionType(
+            this.basicInputDto,
+            PageSettingsDto
+          ),
+          getSpecificFields(this.entityClass, "notQueryable")
+        )
+      ),
+      `Find${this.entityClass.name}Dto`
+    );
+    this.findAllCursorPaginatedDto = 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() {
+    const relations = getTypeormRelations(this.entityClass);
+    const currentLevelRelations = this.options.relations && new Set(
+      getCurrentLevelRelations(
+        this.options.relations.map(extractRelationName)
+      )
+    );
+    const outputFieldsToOmit = /* @__PURE__ */ new Set([
+      ...getNotInResultFields(
+        this.entityClass,
+        this.options.keepEntityVersioningDates
+      ),
+      ...this.options.outputFieldsToOmit || [],
+      ...this.options.relations ? relations.map((r) => r.propertyName).filter((r) => !currentLevelRelations.has(r)) : []
+    ]);
+    const resultDto = OmitType2(this.entityClass, [...outputFieldsToOmit]);
+    for (const relation of relations) {
+      if (outputFieldsToOmit.has(relation.propertyName)) continue;
+      const replace = (useClass) => {
+        const oldApiProperty = Reflect.getMetadata(
+          DECORATORS.API_MODEL_PROPERTIES,
+          this.entityClass.prototype,
+          relation.propertyName
+        ) || {};
+        ApiProperty5({
+          ...oldApiProperty,
+          required: false,
+          type: () => relation.isArray ? [useClass[0]] : useClass[0]
+        })(resultDto.prototype, relation.propertyName);
+      };
+      const existing = this.__resolveVisited.get(relation.propertyClass);
+      if (existing) {
+        replace(existing);
+      } else {
+        if (!this.__resolveVisited.has(this.entityClass) && !this.options.relations) {
+          this.__resolveVisited.set(this.entityClass, [null]);
+        }
+        const relationFactory = new _RestfulFactory(
+          relation.propertyClass,
+          {
+            entityClassName: `${this.getEntityClassName()}${this.options.relations ? upperFirst(relation.propertyName) : relation.propertyClass.name}`,
+            relations: this.options.relations && getNextLevelRelations(
+              this.options.relations.map(extractRelationName),
+              relation.propertyName
+            ),
+            keepEntityVersioningDates: this.options.keepEntityVersioningDates
+          },
+          this.__resolveVisited
+        );
+        const relationResultDto = relationFactory.entityResultDto;
+        replace([relationResultDto]);
+        if (!this.options.relations) {
+          this.__resolveVisited.set(relation.propertyClass, [
+            relationResultDto
+          ]);
+        }
+      }
+    }
+    const res = RenameClass(
+      resultDto,
+      `${this.getEntityClassName()}ResultDto`
+    );
+    const currentContainer = this.__resolveVisited.get(this.entityClass);
+    if (currentContainer) {
+      currentContainer[0] = res;
+    }
+    return res;
+  }
+  usePrefix(methodDec, path) {
+    if (path) {
+      if (this.options.prefix) {
+        return methodDec(`${this.options.prefix}/${path}`);
+      } else {
+        return methodDec(path);
+      }
+    } else {
+      if (this.options.prefix) {
+        return methodDec(this.options.prefix);
+      } else {
+        return methodDec();
+      }
+    }
+  }
+  create(extras = {}) {
+    return MergeMethodDecorators([
+      this.usePrefix(Post),
+      HttpCode(200),
+      ApiOperation({
+        summary: `Create a new ${this.getEntityClassName()}`,
+        ...extras
+      }),
+      ApiBody({ type: this.createDto }),
+      ApiOkResponse({ type: this.entityCreateReturnMessageDto }),
+      ApiBadRequestResponse({
+        type: BlankReturnMessageDto3,
+        description: `The ${this.getEntityClassName()} is not valid`
+      })
+    ]);
+  }
+  createParam() {
+    return Body(CreatePipe());
+  }
+  findOne(extras = {}) {
+    return MergeMethodDecorators([
+      this.usePrefix(Get, ":id"),
+      ApiOperation({
+        summary: `Find a ${this.getEntityClassName()} by id`,
+        ...extras
+      }),
+      ApiParam({ name: "id", type: this.idType, required: true }),
+      ApiOkResponse({ type: this.entityReturnMessageDto }),
+      ApiNotFoundResponse({
+        type: BlankReturnMessageDto3,
+        description: `The ${this.getEntityClassName()} with the given id was not found`
+      })
+    ]);
+  }
+  idParam() {
+    if (this.idType === Number) {
+      return Param("id", ParseIntPipe);
+    } else {
+      return Param("id");
+    }
+  }
+  findAll(extras = {}) {
+    return MergeMethodDecorators([
+      this.usePrefix(Get),
+      ApiOperation({
+        summary: `Find all ${this.getEntityClassName()}`,
+        ...extras
+      }),
+      ApiOkResponse({ type: this.entityArrayReturnMessageDto })
+    ]);
+  }
+  findAllCursorPaginated(extras = {}) {
+    return MergeMethodDecorators([
+      this.usePrefix(Get),
+      ApiOperation({
+        summary: `Find all ${this.getEntityClassName()}`,
+        ...extras
+      }),
+      ApiOkResponse({ type: this.entityCursorPaginationReturnMessageDto })
+    ]);
+  }
+  findAllParam() {
+    return Query(GetPipe());
+  }
+  update(extras = {}) {
+    return MergeMethodDecorators([
+      this.usePrefix(Patch, ":id"),
+      HttpCode(200),
+      ApiOperation({
+        summary: `Update a ${this.getEntityClassName()} by id`,
+        ...extras
+      }),
+      ApiParam({ name: "id", type: this.idType, required: true }),
+      ApiBody({ type: this.updateDto }),
+      ApiOkResponse({ type: BlankReturnMessageDto3 }),
+      ApiNotFoundResponse({
+        type: BlankReturnMessageDto3,
+        description: `The ${this.getEntityClassName()} with the given id was not found`
+      }),
+      ApiBadRequestResponse({
+        type: BlankReturnMessageDto3,
+        description: `The ${this.getEntityClassName()} is not valid`
+      }),
+      ApiInternalServerErrorResponse({
+        type: BlankReturnMessageDto3,
+        description: "Internal error"
+      })
+    ]);
+  }
+  updateParam() {
+    return Body(UpdatePipe());
+  }
+  delete(extras = {}) {
+    return MergeMethodDecorators([
+      this.usePrefix(Delete, ":id"),
+      HttpCode(200),
+      ApiOperation({
+        summary: `Delete a ${this.getEntityClassName()} by id`,
+        ...extras
+      }),
+      ApiParam({ name: "id", type: this.idType, required: true }),
+      ApiOkResponse({ type: BlankReturnMessageDto3 }),
+      ApiNotFoundResponse({
+        type: BlankReturnMessageDto3,
+        description: `The ${this.getEntityClassName()} with the given id was not found`
+      }),
+      ApiInternalServerErrorResponse({
+        type: BlankReturnMessageDto3,
+        description: "Internal error"
+      })
+    ]);
+  }
+  import(extras = {}) {
+    return MergeMethodDecorators([
+      Post("import"),
+      HttpCode(200),
+      ApiOperation({
+        summary: `Import ${this.getEntityClassName()}`,
+        ...extras
+      }),
+      ApiBody({ type: this.importDto }),
+      ApiOkResponse({ type: this.importReturnMessageDto }),
+      ApiInternalServerErrorResponse({
+        type: BlankReturnMessageDto3,
+        description: "Internal error"
+      })
+    ]);
+  }
+  baseController(routeOptions = {}) {
+    const _this = this;
+    const cl = class SpecificRestfulController extends BaseRestfulController {
+      constructor(service) {
+        super(service, {
+          paginateType: routeOptions.paginateType || "offset",
+          relations: _this.options.relations,
+          entityClass: _this.entityClass
+        });
+      }
+    };
+    const anyTrueWritten = RestfulMethods.some(
+      (m) => routeOptions?.routes?.[m]?.enabled === true
+    );
+    const validMethods = RestfulMethods.filter((m) => {
+      const value = routeOptions?.routes?.[m]?.enabled;
+      if (value === false) return false;
+      if (value === true) return true;
+      return !anyTrueWritten || value === true;
+    });
+    const useDecorators = {
+      findOne: {
+        paramTypes: [this.idType],
+        paramDecorators: () => [this.idParam()],
+        methodDecorators: () => [this.findOne()]
+      },
+      findAll: {
+        paramTypes: [
+          routeOptions.paginateType === "cursor" ? this.findAllCursorPaginatedDto : routeOptions.paginateType === "none" ? OmitType2(this.findAllDto, [
+            "pageCount",
+            "recordsPerPage"
+          ]) : this.findAllDto
+        ],
+        paramDecorators: () => [this.findAllParam()],
+        methodDecorators: () => [
+          routeOptions.paginateType === "cursor" ? this.findAllCursorPaginated() : this.findAll()
+        ]
+      },
+      create: {
+        paramTypes: [this.createDto],
+        paramDecorators: () => [this.createParam()],
+        methodDecorators: () => [this.create()]
+      },
+      update: {
+        paramTypes: [this.idType, this.updateDto],
+        paramDecorators: () => [this.idParam(), this.updateParam()],
+        methodDecorators: () => [this.update()]
+      },
+      delete: {
+        paramTypes: [this.idType],
+        paramDecorators: () => [this.idParam()],
+        methodDecorators: () => [this.delete()]
+      },
+      import: {
+        paramTypes: [this.importDto],
+        paramDecorators: () => [this.createParam()],
+        methodDecorators: () => [this.import()]
+      }
+    };
+    for (const method of validMethods) {
+      const methodImpl = function namedMethodImpl(...args) {
+        return BaseRestfulController.prototype[method].apply(this, args);
+      };
+      Object.defineProperty(methodImpl, "name", {
+        value: method,
+        configurable: true
+      });
+      cl.prototype[method] = methodImpl;
+      const paramDecorators = useDecorators[method].paramDecorators();
+      const paramTypes = useDecorators[method].paramTypes;
+      const methodDecorators = [
+        ...useDecorators[method].methodDecorators(),
+        ...routeOptions?.routes?.[method]?.methodDecorators || [],
+        ...routeOptions?.globalMethodDecorators || []
+      ];
+      paramDecorators.forEach((paramDecorator, index) => {
+        paramDecorator(cl.prototype, method, index);
+      });
+      Reflect.defineMetadata(
+        "design:paramtypes",
+        paramTypes,
+        cl.prototype,
+        method
+      );
+      const baseDescriptor = Object.getOwnPropertyDescriptor(
+        BaseRestfulController.prototype,
+        method
+      );
+      if (baseDescriptor) {
+        Reflect.defineMetadata(
+          "design:type",
+          baseDescriptor.value,
+          cl.prototype,
+          method
+        );
+        Reflect.defineMetadata(
+          "design:returntype",
+          Promise,
+          cl.prototype,
+          method
+        );
+      }
+      methodDecorators.forEach((methodDecorator) => {
+        const descriptor = Object.getOwnPropertyDescriptor(
+          cl.prototype,
+          method
+        );
+        methodDecorator(cl.prototype, method, descriptor);
+        Object.defineProperty(cl.prototype, method, descriptor);
+      });
+    }
+    return RenameClass(cl, `${this.getEntityClassName()}Controller`);
+  }
+  crudService(options = {}) {
+    return CrudService(this.entityClass, {
+      relations: this.options.relations,
+      ...options
+    });
+  }
+};
+export {
+  BlankCursorPaginationReturnMessageDto,
+  BoolColumn,
+  CreatePipe,
+  CrudBase,
+  CrudService,
+  CursorPaginationDto,
+  CursorPaginationReturnMessageDto,
+  DateColumn,
+  EnumColumn,
+  FloatColumn,
+  GenericCursorPaginationReturnMessageDto,
+  GetPipe,
+  IdBase,
+  ImportDataBaseDto,
+  ImportDataDto,
+  ImportEntryBaseDto,
+  ImportEntryDto,
+  Inner,
+  IntColumn,
+  JsonColumn,
+  NotChangeable,
+  NotColumn,
+  NotInResult,
+  NotQueryable,
+  NotWritable,
+  PageSettingsDto,
+  QueryColumn,
+  QueryCondition,
+  QueryEqual,
+  QueryEqualZeroNullable,
+  QueryFullText,
+  QueryGreater,
+  QueryGreaterEqual,
+  QueryLess,
+  QueryLessEqual,
+  QueryLike,
+  QueryMatchBoolean,
+  QueryNotEqual,
+  QueryOperator,
+  QuerySearch,
+  Relation,
+  RelationComputed,
+  RestfulFactory,
+  StringColumn,
+  StringIdBase,
+  TimeBase,
+  UpdatePipe,
+  applyQueryMatchBoolean,
+  applyQueryProperty,
+  applyQueryPropertyLike,
+  applyQueryPropertySearch,
+  applyQueryPropertyZeroNullable,
+  createQueryCondition,
+  createQueryOperator
+};
+//# sourceMappingURL=index.mjs.map