bigal 12.1.5 → 13.0.0-beta2

package/dist/index.cjs

@@ -0,0 +1,2626 @@
+'use strict';
+
+const _ = require('lodash');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }
+
+const ___default = /*#__PURE__*/_interopDefaultCompat(_);
+
+var __defProp$7 = Object.defineProperty;
+var __defNormalProp$7 = (obj, key, value) => key in obj ? __defProp$7(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$7 = (obj, key, value) => {
+  __defNormalProp$7(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+class MetadataStorage {
+  constructor() {
+    __publicField$7(this, "models", []);
+    // All columns for all models. This data only represents @column specifics, not additional column modifiers
+    __publicField$7(this, "columns", []);
+    // This represents additional column behavior separate from the main @column decorator. For example, @primaryColumn, @versionColumn, etc
+    // This behavior will be merged over defaults from @column()
+    __publicField$7(this, "columnModifiers", []);
+  }
+}
+
+var __defProp$6 = Object.defineProperty;
+var __defNormalProp$6 = (obj, key, value) => key in obj ? __defProp$6(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$6 = (obj, key, value) => {
+  __defNormalProp$6(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+class ColumnBaseMetadata {
+  constructor({
+    target,
+    name,
+    propertyName,
+    required = false,
+    insert = true,
+    update = true,
+    primary = false,
+    createDate = false,
+    updateDate = false,
+    version = false
+  }) {
+    /**
+     * Name of class with @table decorator
+     */
+    __publicField$6(this, "target");
+    /**
+     * Column name in the database
+     */
+    __publicField$6(this, "name");
+    /**
+     * Class property to which the column is applied
+     */
+    __publicField$6(this, "propertyName");
+    /**
+     * Indicates if a value is required for creates.
+     */
+    __publicField$6(this, "required");
+    /**
+     * Indicates if column is inserted by default. Default is true
+     */
+    __publicField$6(this, "insert");
+    /**
+     * Indicates if column value is updated by "save" operation. Default is true
+     */
+    __publicField$6(this, "update");
+    /**
+     * Indicates if this column is a primary key.
+     * Same can be achieved when @primaryColumn decorator is used
+     */
+    __publicField$6(this, "primary");
+    /**
+     * Value will be equal to `new Date()` when the row is inserted into the table
+     * Same can be achieved when @createDateColumn decorator is used
+     */
+    __publicField$6(this, "createDate");
+    /**
+     * Value will be equal to `new Date()` when the row is updated
+     * Same can be achieved when @updateDateColumn decorator is used
+     */
+    __publicField$6(this, "updateDate");
+    /**
+     * Value will be set to 1 when the row is inserted. Value will be incremented by one when the row is updated
+     * Same can be achieved when @versionColumn decorator is used
+     */
+    __publicField$6(this, "version");
+    this.target = target;
+    this.name = name;
+    this.propertyName = propertyName;
+    this.required = required;
+    this.insert = insert;
+    this.update = update;
+    this.primary = primary;
+    this.createDate = createDate;
+    this.updateDate = updateDate;
+    this.version = version;
+  }
+}
+
+var __defProp$5 = Object.defineProperty;
+var __defNormalProp$5 = (obj, key, value) => key in obj ? __defProp$5(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$5 = (obj, key, value) => {
+  __defNormalProp$5(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+class ColumnCollectionMetadata extends ColumnBaseMetadata {
+  constructor({
+    target,
+    //
+    name,
+    propertyName,
+    required,
+    insert,
+    update,
+    primary,
+    createDate,
+    updateDate,
+    version,
+    collection,
+    via,
+    through
+  }) {
+    super({
+      target,
+      name,
+      propertyName,
+      required,
+      insert,
+      update,
+      primary,
+      createDate,
+      updateDate,
+      version
+    });
+    __publicField$5(this, "_collectionString");
+    __publicField$5(this, "_collectionFn");
+    __publicField$5(this, "_throughString");
+    __publicField$5(this, "_throughFn");
+    /**
+     * Property name of the on the collection item type
+     */
+    __publicField$5(this, "via");
+    this.via = via;
+    if (typeof collection === "string") {
+      this._collectionString = collection;
+    } else {
+      this._collectionFn = collection;
+    }
+    if (typeof through === "string") {
+      this._throughString = through;
+    } else if (through) {
+      this._throughFn = through;
+    }
+  }
+  /**
+   * Type of the items in the collection
+   */
+  get collection() {
+    if (this._collectionString) {
+      return this._collectionString;
+    }
+    if (!this._collectionFn) {
+      throw new Error(`Unable to determine collection type for ${this.target}#${this.propertyName}`);
+    }
+    this._collectionString = this._collectionFn();
+    return this._collectionString;
+  }
+  /**
+   * Name of the junction table for multi-multi associations
+   */
+  get through() {
+    if (this._throughString) {
+      return this._throughString;
+    }
+    if (this._throughFn) {
+      this._throughString = this._throughFn();
+      return this._throughString;
+    }
+    return void 0;
+  }
+}
+
+var __defProp$4 = Object.defineProperty;
+var __defNormalProp$4 = (obj, key, value) => key in obj ? __defProp$4(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$4 = (obj, key, value) => {
+  __defNormalProp$4(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+class ColumnModelMetadata extends ColumnBaseMetadata {
+  constructor({
+    target,
+    //
+    name,
+    propertyName,
+    required,
+    insert,
+    update,
+    primary,
+    createDate,
+    updateDate,
+    version,
+    model
+  }) {
+    super({
+      target,
+      name,
+      propertyName,
+      required,
+      insert,
+      update,
+      primary,
+      createDate,
+      updateDate,
+      version
+    });
+    __publicField$4(this, "_modelString");
+    __publicField$4(this, "_modelFn");
+    if (typeof model === "string") {
+      this._modelString = model;
+    } else {
+      this._modelFn = model;
+    }
+  }
+  /**
+   * Name of the model represented by this column id
+   */
+  get model() {
+    if (this._modelString) {
+      return this._modelString;
+    }
+    if (!this._modelFn) {
+      throw new Error(`Unable to determine model type for ${this.target}#${this.propertyName}`);
+    }
+    this._modelString = this._modelFn();
+    return this._modelString;
+  }
+}
+
+var __defProp$3 = Object.defineProperty;
+var __defNormalProp$3 = (obj, key, value) => key in obj ? __defProp$3(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$3 = (obj, key, value) => {
+  __defNormalProp$3(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+class ColumnTypeMetadata extends ColumnBaseMetadata {
+  constructor(options) {
+    super({
+      target: options.target,
+      name: options.name,
+      propertyName: options.propertyName,
+      required: options.required,
+      insert: options.insert,
+      update: options.update,
+      primary: options.primary,
+      createDate: options.createDate,
+      updateDate: options.updateDate,
+      version: options.version
+    });
+    /**
+     * Type of the column
+     */
+    __publicField$3(this, "type");
+    /**
+     * Default database value
+     */
+    __publicField$3(this, "defaultsTo");
+    /**
+     * Array of possible enumerated values
+     */
+    __publicField$3(this, "enum");
+    /**
+     * If set, enforces a maximum length check on the column
+     *
+     * Applies to types: string | string[]
+     */
+    __publicField$3(this, "maxLength");
+    this.type = options.type;
+    this.defaultsTo = options.defaultsTo;
+    this.enum = options.enum;
+    this.maxLength = options.maxLength;
+  }
+}
+
+var __defProp$2 = Object.defineProperty;
+var __defNormalProp$2 = (obj, key, value) => key in obj ? __defProp$2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$2 = (obj, key, value) => {
+  __defNormalProp$2(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+class ModelMetadata {
+  constructor({
+    name,
+    //
+    type,
+    connection,
+    tableName,
+    readonly = false
+  }) {
+    __publicField$2(this, "_columns", []);
+    __publicField$2(this, "_primaryKeyColumn");
+    __publicField$2(this, "_createDateColumns", []);
+    __publicField$2(this, "_updateDateColumns", []);
+    __publicField$2(this, "_versionDateColumns", []);
+    __publicField$2(this, "name");
+    __publicField$2(this, "type");
+    __publicField$2(this, "connection");
+    __publicField$2(this, "tableName");
+    __publicField$2(this, "readonly");
+    __publicField$2(this, "columnsByColumnName", {});
+    __publicField$2(this, "columnsByPropertyName", {});
+    this.name = name;
+    this.type = type;
+    this.connection = connection;
+    this.tableName = tableName ?? ___default.snakeCase(name);
+    this.readonly = readonly;
+  }
+  set columns(columns) {
+    this._columns = columns;
+    this.columnsByColumnName = {};
+    this.columnsByPropertyName = {};
+    for (const column of columns) {
+      this.columnsByColumnName[column.name] = column;
+      this.columnsByPropertyName[column.propertyName] = column;
+      if (column.primary) {
+        this._primaryKeyColumn = column;
+      }
+      if (column.createDate) {
+        this._createDateColumns.push(column);
+      }
+      if (column.updateDate) {
+        this._updateDateColumns.push(column);
+      }
+      if (column.version) {
+        this._versionDateColumns.push(column);
+      }
+    }
+  }
+  get columns() {
+    return this._columns;
+  }
+  get primaryKeyColumn() {
+    return this._primaryKeyColumn;
+  }
+  get createDateColumns() {
+    return this._createDateColumns;
+  }
+  get updateDateColumns() {
+    return this._updateDateColumns;
+  }
+  get versionColumns() {
+    return this._versionDateColumns;
+  }
+}
+
+function getMetadataStorage() {
+  if (!global.bigAlMetadataArgsStorage) {
+    global.bigAlMetadataArgsStorage = new MetadataStorage();
+  }
+  return global.bigAlMetadataArgsStorage;
+}
+
+var __defProp$1 = Object.defineProperty;
+var __defNormalProp$1 = (obj, key, value) => key in obj ? __defProp$1(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$1 = (obj, key, value) => {
+  __defNormalProp$1(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+class QueryError extends Error {
+  constructor(message, model, where) {
+    super(message);
+    __publicField$1(this, "model");
+    __publicField$1(this, "where");
+    this.name = "QueryError";
+    this.model = model;
+    this.where = where;
+    Object.setPrototypeOf(this, QueryError.prototype);
+  }
+}
+
+function getSelectQueryAndParams({
+  repositoriesByModelNameLowered,
+  model,
+  select,
+  where,
+  sorts,
+  skip,
+  limit
+}) {
+  let query = "SELECT ";
+  query += getColumnsToSelect({
+    model,
+    select
+  });
+  query += ` FROM "${model.tableName}"`;
+  const { whereStatement, params } = buildWhereStatement({
+    repositoriesByModelNameLowered,
+    model,
+    where
+  });
+  if (whereStatement) {
+    query += ` ${whereStatement}`;
+  }
+  const orderStatement = buildOrderStatement({
+    model,
+    sorts
+  });
+  if (orderStatement) {
+    query += ` ${orderStatement}`;
+  }
+  if (limit) {
+    if (___default.isString(limit)) {
+      limit = Number(limit);
+    }
+    if (!___default.isFinite(limit)) {
+      throw new QueryError("Limit should be a number", model, where);
+    }
+    query += ` LIMIT ${limit}`;
+  }
+  if (skip) {
+    if (___default.isString(skip)) {
+      skip = Number(skip);
+    }
+    if (!___default.isFinite(skip)) {
+      throw new QueryError("Skip should be a number", model, where);
+    }
+    query += ` OFFSET ${skip}`;
+  }
+  if (process.env.DEBUG_BIGAL?.toLowerCase() === "true") {
+    console.log(`BigAl: ${query}`);
+  }
+  return {
+    query,
+    params
+  };
+}
+function getCountQueryAndParams({
+  repositoriesByModelNameLowered,
+  model,
+  where
+}) {
+  let query = `SELECT count(*) AS "count" FROM "${model.tableName}"`;
+  const { whereStatement, params } = buildWhereStatement({
+    repositoriesByModelNameLowered,
+    model,
+    where
+  });
+  if (whereStatement) {
+    query += ` ${whereStatement}`;
+  }
+  return {
+    query,
+    params
+  };
+}
+function getInsertQueryAndParams({
+  repositoriesByModelNameLowered,
+  model,
+  values,
+  returnRecords = true,
+  returnSelect,
+  onConflict
+}) {
+  const entitiesToInsert = ___default.isArray(values) ? values : [values];
+  const conflictTargetColumns = [];
+  const columnsToInsert = [];
+  const columnsToMerge = [];
+  let hasEmptyMergeColumns = false;
+  for (const column of model.columns) {
+    const collectionColumn = column;
+    if (!collectionColumn.collection) {
+      const { defaultsTo } = column;
+      let defaultValue;
+      if (___default.isFunction(defaultsTo)) {
+        defaultValue = defaultsTo();
+      } else if (!___default.isUndefined(defaultsTo)) {
+        defaultValue = defaultsTo;
+      } else if (column.createDate) {
+        defaultValue = /* @__PURE__ */ new Date();
+      } else if (column.updateDate) {
+        defaultValue = /* @__PURE__ */ new Date();
+      } else if (column.version) {
+        defaultValue = 1;
+      }
+      const hasDefaultValue = !___default.isUndefined(defaultValue);
+      let includePropertyName = false;
+      for (const entity of entitiesToInsert) {
+        if (hasDefaultValue && ___default.isUndefined(entity[column.propertyName])) {
+          entity[column.propertyName] = defaultValue;
+        }
+        if (___default.isUndefined(entity[column.propertyName])) {
+          if (column.required) {
+            throw new QueryError(`Create statement for "${model.name}" is missing value for required field: ${column.propertyName}`, model);
+          }
+        } else {
+          includePropertyName = true;
+          const { maxLength, type } = column;
+          if (maxLength && ["string", "string[]"].includes(type)) {
+            const entityValues = entity[column.propertyName] ?? "";
+            const normalizedValues = Array.isArray(entityValues) ? entityValues : [entityValues];
+            for (const normalizedValue of normalizedValues) {
+              if (normalizedValue.length > maxLength) {
+                throw new QueryError(`Create statement for "${model.name}" contains a value that exceeds maxLength on field: ${column.propertyName}`, model);
+              }
+            }
+          }
+        }
+      }
+      if (includePropertyName) {
+        columnsToInsert.push(column);
+      }
+      if (onConflict) {
+        if (Array.isArray(onConflict.targets) && onConflict.targets.includes(column.propertyName) || !Array.isArray(onConflict.targets) && onConflict.targets.columns.includes(column.propertyName)) {
+          conflictTargetColumns.push(column);
+        }
+        if (onConflict.action === "merge") {
+          const mergeColumns = Array.isArray(onConflict.merge) ? onConflict.merge : onConflict.merge?.columns;
+          if (mergeColumns) {
+            hasEmptyMergeColumns = !mergeColumns.length;
+            if (mergeColumns.includes(column.propertyName)) {
+              columnsToMerge.push(column);
+            }
+          } else if (!column.createDate && !column.primary) {
+            columnsToMerge.push(column);
+          }
+        }
+      }
+    }
+  }
+  const valueCollections = entitiesToInsert.map(() => []);
+  const params = [];
+  let query = `INSERT INTO "${model.tableName}" (`;
+  for (const [columnIndex, column] of columnsToInsert.entries()) {
+    if (columnIndex > 0) {
+      query += ",";
+    }
+    query += `"${column.name}"`;
+    for (const [entityIndex, entity] of entitiesToInsert.entries()) {
+      let value;
+      const entityValue = entity[column.propertyName];
+      if (___default.isNil(entityValue)) {
+        value = "NULL";
+      } else {
+        const isJsonArray = column.type === "json" && ___default.isArray(entityValue);
+        const relatedModelName = column.model;
+        if (relatedModelName && ___default.isObject(entityValue)) {
+          const relatedModelRepository = repositoriesByModelNameLowered[relatedModelName.toLowerCase()];
+          if (!relatedModelRepository) {
+            throw new QueryError(`Unable to find model schema (${relatedModelName}) specified as model type for "${column.propertyName}" on "${model.name}"`, model);
+          }
+          const relatedModelPrimaryKey = relatedModelRepository.model.primaryKeyColumn;
+          if (!relatedModelPrimaryKey) {
+            throw new QueryError(`Unable to find primary key column for ${relatedModelName} when inserting ${model.name}.${column.propertyName} value.`, model);
+          }
+          const primaryKeyValue = entityValue[relatedModelPrimaryKey.propertyName];
+          if (___default.isNil(primaryKeyValue)) {
+            throw new QueryError(`Undefined primary key value for hydrated object value for "${column.propertyName}" on "${model.name}"`, model);
+          }
+          params.push(primaryKeyValue);
+        } else if (isJsonArray) {
+          params.push(JSON.stringify(entityValue));
+        } else {
+          params.push(entityValue);
+        }
+        value = `$${params.length}`;
+        if (isJsonArray) {
+          value += "::jsonb";
+        }
+      }
+      const valuesForEntityIndex = valueCollections[entityIndex];
+      if (!valuesForEntityIndex) {
+        throw new QueryError("Error trying to get insert values for entity index", model);
+      }
+      valuesForEntityIndex.push(value);
+    }
+  }
+  query += ") VALUES ";
+  for (const [index, valueCollection] of valueCollections.entries()) {
+    if (index > 0) {
+      query += ",";
+    }
+    query += `(${valueCollection.join(",")})`;
+  }
+  if (onConflict) {
+    query += " ON CONFLICT (";
+    for (const [index, targetColumn] of conflictTargetColumns.entries()) {
+      if (index > 0) {
+        query += ",";
+      }
+      query += `"${targetColumn.name}"`;
+    }
+    query += ") ";
+    if (!Array.isArray(onConflict.targets)) {
+      const { whereStatement } = buildWhereStatement({
+        repositoriesByModelNameLowered,
+        model,
+        where: onConflict.targets.where,
+        params
+      });
+      if (whereStatement) {
+        query += `${whereStatement} `;
+      }
+    }
+    if (onConflict.action === "ignore" || hasEmptyMergeColumns) {
+      query += "DO NOTHING";
+    } else {
+      query += "DO UPDATE SET ";
+      for (const [index, column] of columnsToMerge.entries()) {
+        if (index > 0) {
+          query += ",";
+        }
+        if (column.version) {
+          query += `"${column.name}"="${column.name}"+1`;
+        } else {
+          query += `"${column.name}"=EXCLUDED."${column.name}"`;
+        }
+      }
+      if (!Array.isArray(onConflict.merge) && onConflict.merge?.where) {
+        const { whereStatement } = buildWhereStatement({
+          repositoriesByModelNameLowered,
+          model,
+          where: onConflict.merge.where,
+          params
+        });
+        if (whereStatement) {
+          query += ` ${whereStatement}`;
+        }
+      }
+    }
+  }
+  if (returnRecords) {
+    query += " RETURNING ";
+    query += getColumnsToSelect({
+      model,
+      select: returnSelect
+    });
+  }
+  return {
+    query,
+    params
+  };
+}
+function getUpdateQueryAndParams({
+  repositoriesByModelNameLowered,
+  model,
+  where,
+  values = {},
+  returnRecords = true,
+  returnSelect
+}) {
+  for (const column of model.updateDateColumns) {
+    if (___default.isUndefined(values[column.propertyName])) {
+      values[column.propertyName] = /* @__PURE__ */ new Date();
+    }
+  }
+  const params = [];
+  let query = `UPDATE "${model.tableName}" SET `;
+  let isFirstProperty = true;
+  for (const [propertyName, value] of Object.entries(values)) {
+    const column = model.columnsByPropertyName[propertyName];
+    if (column && !column.collection) {
+      if (!isFirstProperty) {
+        query += ",";
+      }
+      query += `"${column.name}"=`;
+      if (___default.isNil(value)) {
+        query += "NULL";
+      } else {
+        const isJsonArray = column.type === "json" && ___default.isArray(value);
+        const relatedModelName = column.model;
+        const { maxLength, type } = column;
+        if (maxLength && ["string", "string[]"].includes(type)) {
+          const normalizedValues = Array.isArray(value) ? value : [value];
+          for (const normalizedValue of normalizedValues) {
+            if (normalizedValue?.length > maxLength) {
+              throw new QueryError(`Update statement for "${model.name}" contains a value that exceeds maxLength on field: ${column.propertyName}`, model);
+            }
+          }
+        }
+        if (relatedModelName && ___default.isObject(value)) {
+          const relatedModelRepository = repositoriesByModelNameLowered[relatedModelName.toLowerCase()];
+          if (!relatedModelRepository) {
+            throw new QueryError(`Unable to find model schema (${relatedModelName}) specified as model type for "${propertyName}" on "${model.name}"`, model);
+          }
+          const relatedModelPrimaryKey = relatedModelRepository.model.primaryKeyColumn;
+          if (!relatedModelPrimaryKey) {
+            throw new QueryError(`Unable to find primary key column for ${relatedModelName} when inserting ${model.name}.${column.propertyName} value.`, model);
+          }
+          const primaryKeyValue = value[relatedModelPrimaryKey.propertyName];
+          if (___default.isNil(primaryKeyValue)) {
+            throw new QueryError(`Undefined primary key value for hydrated object value for "${column.propertyName}" on "${model.name}"`, model);
+          }
+          params.push(primaryKeyValue);
+        } else if (isJsonArray) {
+          params.push(JSON.stringify(value));
+        } else {
+          params.push(value);
+        }
+        query += `$${params.length}`;
+        if (isJsonArray) {
+          query += "::jsonb";
+        }
+      }
+      isFirstProperty = false;
+    }
+  }
+  for (const column of model.versionColumns) {
+    if (!___default.isUndefined(values[column.propertyName])) {
+      if (!isFirstProperty) {
+        query += ",";
+      }
+      query += `"${column.name}"="${column.name}"+1`;
+      isFirstProperty = false;
+    }
+  }
+  const { whereStatement } = buildWhereStatement({
+    repositoriesByModelNameLowered,
+    model,
+    where,
+    params
+  });
+  if (whereStatement) {
+    query += ` ${whereStatement}`;
+  }
+  if (returnRecords) {
+    query += " RETURNING ";
+    query += getColumnsToSelect({
+      model,
+      select: returnSelect
+    });
+  }
+  return {
+    query,
+    params
+  };
+}
+function getDeleteQueryAndParams({
+  repositoriesByModelNameLowered,
+  model,
+  where,
+  returnRecords = true,
+  returnSelect
+}) {
+  let query = `DELETE FROM "${model.tableName}"`;
+  const { whereStatement, params } = buildWhereStatement({
+    repositoriesByModelNameLowered,
+    model,
+    where
+  });
+  if (whereStatement) {
+    query += ` ${whereStatement}`;
+  }
+  if (returnRecords) {
+    query += " RETURNING ";
+    query += getColumnsToSelect({
+      model,
+      select: returnSelect
+    });
+  }
+  return {
+    query,
+    params
+  };
+}
+function getColumnsToSelect({
+  model,
+  select
+}) {
+  let selectColumns;
+  if (select) {
+    const { primaryKeyColumn } = model;
+    selectColumns = new Set(select);
+    if (primaryKeyColumn) {
+      selectColumns.add(primaryKeyColumn.propertyName);
+    }
+  } else {
+    selectColumns = /* @__PURE__ */ new Set();
+    for (const column of model.columns) {
+      if (!column.collection) {
+        selectColumns.add(column.propertyName);
+      }
+    }
+  }
+  let query = "";
+  for (const [index, propertyName] of Array.from(selectColumns).entries()) {
+    const column = model.columnsByPropertyName[propertyName];
+    if (!column) {
+      throw new QueryError(`Unable to find column for property: ${propertyName} on ${model.tableName}`, model);
+    }
+    if (index > 0) {
+      query += ",";
+    }
+    if (column.name === propertyName) {
+      query += `"${propertyName}"`;
+    } else {
+      query += `"${column.name}" AS "${propertyName}"`;
+    }
+  }
+  return query;
+}
+function buildWhereStatement({
+  repositoriesByModelNameLowered,
+  model,
+  where,
+  params = []
+}) {
+  let whereStatement;
+  if (___default.isObject(where) && Object.keys(where).length) {
+    whereStatement = buildWhere({
+      repositoriesByModelNameLowered,
+      model,
+      comparer: "and",
+      value: where,
+      params
+    });
+    if (!whereStatement) {
+      throw new QueryError(`WHERE statement is unexpectedly empty.`, model, where);
+    }
+  }
+  if (whereStatement) {
+    whereStatement = `WHERE ${whereStatement}`;
+  }
+  return {
+    whereStatement,
+    params
+  };
+}
+function buildOrderStatement({ model, sorts }) {
+  if (___default.isNil(sorts) || !___default.some(sorts)) {
+    return "";
+  }
+  let orderStatement = "ORDER BY ";
+  for (const [index, orderProperty] of sorts.entries()) {
+    if (index > 0) {
+      orderStatement += ",";
+    }
+    const { propertyName, descending } = orderProperty;
+    const column = model.columnsByPropertyName[propertyName];
+    if (!column) {
+      throw new QueryError(`Property (${propertyName}) not found in model (${model.name}).`, model);
+    }
+    orderStatement += `"${column.name}"`;
+    if (descending) {
+      orderStatement += " DESC";
+    }
+  }
+  return orderStatement;
+}
+function buildWhere({
+  repositoriesByModelNameLowered,
+  model,
+  propertyName,
+  comparer,
+  isNegated = false,
+  value,
+  params = []
+}) {
+  switch (comparer ?? propertyName) {
+    case "!":
+    case "not":
+      return buildWhere({
+        repositoriesByModelNameLowered,
+        model,
+        propertyName,
+        isNegated: true,
+        value,
+        params
+      });
+    case "or":
+      return buildOrOperatorStatement({
+        repositoriesByModelNameLowered,
+        model,
+        isNegated,
+        value,
+        params
+      });
+    case "contains":
+      if (___default.isArray(value)) {
+        const values = value.map((val) => {
+          if (!___default.isString(val)) {
+            throw new QueryError(`Expected all array values to be strings for "contains" constraint. Property (${propertyName ?? ""}) in model (${model.name}).`, model);
+          }
+          return `%${val}%`;
+        });
+        return buildWhere({
+          repositoriesByModelNameLowered,
+          model,
+          propertyName,
+          comparer: "like",
+          isNegated,
+          value: values,
+          params
+        });
+      }
+      if (___default.isString(value)) {
+        return buildWhere({
+          repositoriesByModelNameLowered,
+          model,
+          propertyName,
+          comparer: "like",
+          isNegated,
+          value: `%${value}%`,
+          params
+        });
+      }
+      throw new QueryError(`Expected value to be a string for "contains" constraint. Property (${propertyName ?? ""}) in model (${model.name}).`, model);
+    case "startsWith":
+      if (___default.isArray(value)) {
+        const values = value.map((val) => {
+          if (!___default.isString(val)) {
+            throw new QueryError(`Expected all array values to be strings for "startsWith" constraint. Property (${propertyName ?? ""}) in model (${model.name}).`, model);
+          }
+          return `${val}%`;
+        });
+        return buildWhere({
+          repositoriesByModelNameLowered,
+          model,
+          propertyName,
+          comparer: "like",
+          isNegated,
+          value: values,
+          params
+        });
+      }
+      if (___default.isString(value)) {
+        return buildWhere({
+          repositoriesByModelNameLowered,
+          model,
+          propertyName,
+          comparer: "like",
+          isNegated,
+          value: `${value}%`,
+          params
+        });
+      }
+      throw new QueryError(`Expected value to be a string for "startsWith" constraint. Property (${propertyName ?? ""}) in model (${model.name}).`, model);
+    case "endsWith":
+      if (___default.isArray(value)) {
+        const values = value.map((val) => {
+          if (!___default.isString(val)) {
+            throw new QueryError(`Expected all array values to be strings for "endsWith" constraint. Property (${propertyName ?? ""}) in model (${model.name}).`, model);
+          }
+          return `%${val}`;
+        });
+        return buildWhere({
+          repositoriesByModelNameLowered,
+          model,
+          propertyName,
+          comparer: "like",
+          isNegated,
+          value: values,
+          params
+        });
+      }
+      if (___default.isString(value)) {
+        return buildWhere({
+          repositoriesByModelNameLowered,
+          model,
+          propertyName,
+          comparer: "like",
+          isNegated,
+          value: `%${value}`,
+          params
+        });
+      }
+      throw new QueryError(`Expected value to be a string for "endsWith" constraint. Property (${propertyName ?? ""}) in model (${model.name}).`, model);
+    case "like":
+      return buildLikeOperatorStatement({
+        model,
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        propertyName,
+        isNegated,
+        value,
+        params
+      });
+    default: {
+      if (___default.isUndefined(value)) {
+        throw new QueryError(`Attempting to query with an undefined value. ${propertyName ?? ""} on ${model.name}`, model);
+      }
+      if (propertyName) {
+        const column = model.columnsByPropertyName[propertyName];
+        if (column && ___default.isObject(value)) {
+          if (column.primary) {
+            const primaryKeyValue = value[column.propertyName];
+            if (!___default.isNil(primaryKeyValue)) {
+              return buildWhere({
+                repositoriesByModelNameLowered,
+                model,
+                propertyName,
+                comparer,
+                isNegated,
+                value: primaryKeyValue,
+                params
+              });
+            }
+          } else if (column.model) {
+            const relatedModelRepository = repositoriesByModelNameLowered[column.model.toLowerCase()];
+            if (!relatedModelRepository) {
+              throw new QueryError(`Unable to find model schema (${column.model}) specified in where clause for "${column.propertyName}"`, model);
+            }
+            const relatedModelPrimaryKey = relatedModelRepository.model.primaryKeyColumn;
+            if (!relatedModelPrimaryKey) {
+              throw new QueryError(`Unable to find primary key column for ${column.model} specified in where clause for ${model.name}.${column.propertyName}`, model);
+            }
+            const primaryKeyValue = value[relatedModelPrimaryKey.propertyName];
+            if (!___default.isNil(primaryKeyValue)) {
+              return buildWhere({
+                repositoriesByModelNameLowered,
+                model,
+                propertyName,
+                comparer,
+                isNegated,
+                value: primaryKeyValue,
+                params
+              });
+            }
+          }
+        }
+      }
+      if (___default.isArray(value)) {
+        if (!value.length) {
+          const columnTypeFromPropertyName = propertyName ? model.columnsByPropertyName[propertyName] : null;
+          const columnTypeFromComparer = comparer ? model.columnsByPropertyName[comparer] : null;
+          const arrayColumn = columnTypeFromPropertyName ?? columnTypeFromComparer;
+          if (arrayColumn) {
+            const arrayColumnType = arrayColumn.type ? arrayColumn.type.toLowerCase() : "";
+            if (arrayColumnType === "array" || arrayColumnType === "string[]" || arrayColumnType === "integer[]" || arrayColumnType === "float[]" || arrayColumnType === "boolean[]") {
+              return `"${arrayColumn.name}"${isNegated ? "<>" : "="}'{}'`;
+            }
+          }
+          if (isNegated) {
+            return "1=1";
+          }
+          return "1<>1";
+        }
+        const orConstraints = [];
+        const valueWithoutNull = [];
+        for (const item of value) {
+          if (___default.isNull(item)) {
+            orConstraints.push(
+              buildWhere({
+                repositoriesByModelNameLowered,
+                model,
+                propertyName,
+                isNegated,
+                value: null,
+                params
+              })
+            );
+          } else if (item === "") {
+            orConstraints.push(
+              buildWhere({
+                repositoriesByModelNameLowered,
+                model,
+                propertyName,
+                isNegated,
+                value: "",
+                params
+              })
+            );
+          } else {
+            valueWithoutNull.push(item);
+          }
+        }
+        if (valueWithoutNull.length === 1) {
+          orConstraints.push(
+            buildWhere({
+              repositoriesByModelNameLowered,
+              model,
+              propertyName,
+              isNegated,
+              value: valueWithoutNull[0],
+              params
+            })
+          );
+        } else if (valueWithoutNull.length) {
+          const columnTypeFromPropertyName = propertyName ? model.columnsByPropertyName[propertyName] : null;
+          const columnTypeFromComparer = comparer ? model.columnsByPropertyName[comparer] : null;
+          const columnType = columnTypeFromPropertyName ?? columnTypeFromComparer;
+          if (columnType) {
+            let columnTypeLowered = columnType.type ? columnType.type.toLowerCase() : "";
+            if (columnTypeLowered === "array" || columnTypeLowered === "string[]" || columnTypeLowered === "integer[]" || columnTypeLowered === "float[]" || columnTypeLowered === "boolean[]") {
+              for (const val of valueWithoutNull) {
+                orConstraints.push(
+                  buildWhere({
+                    repositoriesByModelNameLowered,
+                    model,
+                    propertyName,
+                    isNegated,
+                    value: val,
+                    params
+                  })
+                );
+              }
+            } else {
+              if (!columnTypeLowered) {
+                const columnAsModelType = columnType;
+                if (columnAsModelType.model) {
+                  const relatedModelRepository = repositoriesByModelNameLowered[columnAsModelType.model.toLowerCase()];
+                  if (!relatedModelRepository) {
+                    throw new QueryError(`Unable to find model schema (${columnAsModelType.model}) specified in where clause for "${columnAsModelType.propertyName}"`, model);
+                  }
+                  const relatedModelPrimaryKey = relatedModelRepository.model.primaryKeyColumn;
+                  if (!relatedModelPrimaryKey) {
+                    throw new QueryError(`Unable to find primary key column for ${columnAsModelType.model} specified in where clause for ${model.name}.${columnAsModelType.propertyName}`, model);
+                  }
+                  columnTypeLowered = relatedModelPrimaryKey.type ? relatedModelPrimaryKey.type.toLowerCase() : "";
+                }
+              }
+              let castType;
+              switch (columnTypeLowered) {
+                case "int":
+                case "integer":
+                case "integer[]":
+                  castType = "::INTEGER[]";
+                  break;
+                case "float":
+                case "float[]":
+                  castType = "::NUMERIC[]";
+                  break;
+                case "boolean":
+                case "boolean[]":
+                  castType = "::BOOLEAN[]";
+                  break;
+                default:
+                  castType = "::TEXT[]";
+                  break;
+              }
+              params.push(valueWithoutNull);
+              orConstraints.push(`"${columnType.name}"${isNegated ? "<>ALL" : "=ANY"}($${params.length}${castType})`);
+            }
+          }
+        }
+        if (orConstraints.length === 1) {
+          return orConstraints[0] ?? "";
+        }
+        if (isNegated) {
+          return orConstraints.join(" AND ");
+        }
+        if (orConstraints.length) {
+          return `(${orConstraints.join(" OR ")})`;
+        }
+        return "";
+      }
+      if (___default.isObject(value) && !___default.isDate(value)) {
+        const andValues = [];
+        for (const [key, where] of Object.entries(value)) {
+          let subQueryComparer;
+          if (isComparer(key)) {
+            subQueryComparer = key;
+          } else {
+            propertyName = key;
+          }
+          andValues.push(
+            buildWhere({
+              repositoriesByModelNameLowered,
+              model,
+              propertyName,
+              comparer: subQueryComparer,
+              isNegated,
+              value: where,
+              params
+            })
+          );
+        }
+        return andValues.join(" AND ");
+      }
+      return buildComparisonOperatorStatement({
+        model,
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        propertyName,
+        comparer,
+        isNegated,
+        value,
+        params
+      });
+    }
+  }
+}
+function buildOrOperatorStatement({
+  repositoriesByModelNameLowered,
+  model,
+  isNegated,
+  value,
+  params = []
+}) {
+  const orClauses = [];
+  for (const constraint of value) {
+    const orClause = buildWhere({
+      repositoriesByModelNameLowered,
+      model,
+      isNegated,
+      value: constraint,
+      params
+    });
+    if (orClause) {
+      orClauses.push(`(${orClause})`);
+    }
+  }
+  if (orClauses.length === 1) {
+    return orClauses[0] ?? "";
+  }
+  if (isNegated) {
+    return orClauses.join(" AND ");
+  }
+  if (orClauses.length) {
+    return `(${orClauses.join(" OR ")})`;
+  }
+  return "";
+}
+function buildLikeOperatorStatement({ model, propertyName, isNegated, value, params }) {
+  if (___default.isArray(value)) {
+    if (!value.length) {
+      if (isNegated) {
+        return "1=1";
+      }
+      return "1<>1";
+    }
+    if (value.length > 1) {
+      const orConstraints = [];
+      for (const item of value) {
+        if (___default.isNull(item)) {
+          orConstraints.push(
+            buildLikeOperatorStatement({
+              model,
+              propertyName,
+              isNegated,
+              value: null,
+              params
+            })
+          );
+        } else if (item === "") {
+          orConstraints.push(
+            buildLikeOperatorStatement({
+              model,
+              propertyName,
+              isNegated,
+              value: "",
+              params
+            })
+          );
+        } else {
+          orConstraints.push(
+            buildLikeOperatorStatement({
+              model,
+              propertyName,
+              isNegated,
+              value: item,
+              params
+            })
+          );
+        }
+      }
+      if (orConstraints.length === 1) {
+        return orConstraints[0] ?? "";
+      }
+      if (isNegated) {
+        return orConstraints.join(" AND ");
+      }
+      if (orConstraints.length) {
+        return `(${orConstraints.join(" OR ")})`;
+      }
+      return "";
+    }
+    value = value[0];
+  }
+  const column = model.columnsByPropertyName[propertyName];
+  if (!column) {
+    throw new QueryError(`Unable to find property ${propertyName} on model ${model.name}`, model);
+  }
+  if (___default.isNull(value)) {
+    return `"${column.name}" ${isNegated ? "IS NOT" : "IS"} NULL`;
+  }
+  if (___default.isString(value)) {
+    if (value) {
+      params.push(value);
+      const columnType = column.type?.toLowerCase();
+      if (columnType === "array" || columnType === "string[]") {
+        return `${isNegated ? "NOT " : ""}EXISTS(SELECT 1 FROM (SELECT unnest("${column.name}") AS "unnested_${column.name}") __unnested WHERE "unnested_${column.name}" ILIKE $${params.length})`;
+      }
+      return `"${column.name}"${isNegated ? " NOT" : ""} ILIKE $${params.length}`;
+    }
+    return `"${column.name}" ${isNegated ? "!=" : "="} ''`;
+  }
+  throw new QueryError(`Expected value to be a string for "like" constraint. Property (${propertyName}) in model (${model.name}).`, model);
+}
+function buildComparisonOperatorStatement({ model, propertyName, comparer, isNegated, value, params = [] }) {
+  const column = model.columnsByPropertyName[propertyName];
+  if (!column) {
+    throw new QueryError(`Unable to find property ${propertyName} on model ${model.name}`, model);
+  }
+  if (___default.isNull(value)) {
+    return `"${column.name}" ${isNegated ? "IS NOT" : "IS"} NULL`;
+  }
+  params.push(value);
+  const columnType = column.type ?? "unknown";
+  const supportsLessThanGreaterThan = columnType !== "array" && columnType !== "json";
+  switch (comparer) {
+    case "<":
+      if (!supportsLessThanGreaterThan) {
+        throw new QueryError(`< operator is not supported for ${columnType} type. ${propertyName || ""} on ${model.name}`, model);
+      }
+      return `"${column.name}"${isNegated ? ">=" : "<"}$${params.length}`;
+    case "<=":
+      if (!supportsLessThanGreaterThan) {
+        throw new QueryError(`<= operator is not supported for ${columnType} type. ${propertyName || ""} on ${model.name}`, model);
+      }
+      return `"${column.name}"${isNegated ? ">" : "<="}$${params.length}`;
+    case ">":
+      if (!supportsLessThanGreaterThan) {
+        throw new QueryError(`> operator is not supported for ${columnType} type. ${propertyName || ""} on ${model.name}`, model);
+      }
+      return `"${column.name}"${isNegated ? "<=" : ">"}$${params.length}`;
+    case ">=":
+      if (!supportsLessThanGreaterThan) {
+        throw new QueryError(`>= operator is not supported for ${columnType} type. ${propertyName || ""} on ${model.name}`, model);
+      }
+      return `"${column.name}"${isNegated ? "<" : ">="}$${params.length}`;
+    default:
+      if (columnType === "array" || columnType.endsWith("[]")) {
+        return `$${params.length}${isNegated ? "<>ALL(" : "=ANY("}"${column.name}")`;
+      }
+      return `"${column.name}"${isNegated ? "<>" : "="}$${params.length}`;
+  }
+}
+function isComparer(value) {
+  switch (value) {
+    case "!":
+    case "not":
+    case "or":
+    case "and":
+    case "contains":
+    case "startsWith":
+    case "endsWith":
+    case "like":
+    case "<":
+    case "<=":
+    case ">":
+    case ">=":
+      return true;
+    default:
+      return false;
+  }
+}
+
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+class ReadonlyRepository {
+  constructor({ modelMetadata, type, pool, readonlyPool, repositoriesByModelNameLowered }) {
+    __publicField(this, "_modelMetadata");
+    __publicField(this, "_type");
+    __publicField(this, "_pool");
+    __publicField(this, "_readonlyPool");
+    __publicField(this, "_repositoriesByModelNameLowered");
+    __publicField(this, "_floatProperties", []);
+    __publicField(this, "_intProperties", []);
+    this._modelMetadata = modelMetadata;
+    this._type = type;
+    this._pool = pool;
+    this._readonlyPool = readonlyPool ?? pool;
+    this._repositoriesByModelNameLowered = repositoriesByModelNameLowered;
+    for (const column of modelMetadata.columns) {
+      if (column.type === "float") {
+        this._floatProperties.push(column.propertyName);
+      } else if (column.type === "integer") {
+        this._intProperties.push(column.propertyName);
+      }
+    }
+  }
+  get model() {
+    return this._modelMetadata;
+  }
+  /**
+   * Gets a single object
+   * @param {object} [args] - Arguments
+   * @param {string[]} [args.select] - Array of model property names to return from the query.
+   * @param {object} [args.where] - Object representing the where query
+   * @param {string|object} [args.sort] - Property name(s) to sort by
+   */
+  findOne(args = {}) {
+    const { stack } = new Error(`${this.model.name}.findOne()`);
+    let select;
+    let where = {};
+    let sort = null;
+    let poolOverride;
+    for (const [name, value] of Object.entries(args)) {
+      let isWhereCriteria = false;
+      switch (name) {
+        case "select":
+          if (value) {
+            select = new Set(value);
+          }
+          break;
+        case "where":
+          where = value;
+          break;
+        case "sort":
+          sort = value;
+          break;
+        case "pool":
+          poolOverride = value;
+          break;
+        default:
+          select = void 0;
+          where = args;
+          sort = null;
+          isWhereCriteria = true;
+          break;
+      }
+      if (isWhereCriteria) {
+        break;
+      }
+    }
+    const populates = [];
+    const manuallySetFields = [];
+    const sorts = sort ? this._convertSortsToOrderBy(sort) : [];
+    const modelInstance = this;
+    return {
+      /**
+       * Filters the query
+       * @param {object} value - Object representing the where query
+       */
+      where(value) {
+        where = value;
+        return this;
+      },
+      /**
+       * Populates/hydrates relations
+       * @param {string} propertyName - Name of property to join
+       * @param {object} [options] - Populate options
+       * @param {object} [options.where] - Object representing the where query
+       * @param {string[]} [options.select] - Array of model property names to return from the query.
+       * @param {string|object} [options.sort] - Property name(s) to sort by
+       * @param {string|number} [options.skip] - Number of records to skip
+       * @param {string|number} [options.limit] - Number of results to return
+       */
+      populate(propertyName, options) {
+        if (select && !select.has(propertyName)) {
+          for (const column of modelInstance.model.columns) {
+            if (column.model && column.propertyName === propertyName) {
+              select.add(column.propertyName);
+            }
+          }
+        }
+        populates.push({
+          propertyName,
+          where: options?.where,
+          select: options?.select,
+          sort: options?.sort,
+          skip: options?.skip,
+          limit: options?.limit,
+          pool: options?.pool ?? poolOverride
+        });
+        return this;
+      },
+      /**
+       * Sorts the query
+       * @param {string|object} [value]
+       */
+      sort(value) {
+        if (value) {
+          sorts.push(...modelInstance._convertSortsToOrderBy(value));
+        }
+        return this;
+      },
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars
+      UNSAFE_withOriginalFieldType(_propertyName) {
+        return this;
+      },
+      UNSAFE_withFieldValue(propertyName, value) {
+        manuallySetFields.push({
+          propertyName,
+          value
+        });
+        return this;
+      },
+      async then(resolve, reject) {
+        try {
+          if (___default.isString(where)) {
+            return await reject(new Error("The query cannot be a string, it must be an object"));
+          }
+          const { query, params } = getSelectQueryAndParams({
+            repositoriesByModelNameLowered: modelInstance._repositoriesByModelNameLowered,
+            model: modelInstance.model,
+            select: select ? Array.from(select) : void 0,
+            where,
+            sorts,
+            limit: 1,
+            skip: 0
+          });
+          const pool = poolOverride ?? modelInstance._readonlyPool;
+          const results = await pool.query(query, params);
+          const firstResult = ___default.first(results.rows);
+          if (firstResult) {
+            const result = modelInstance._buildInstance(firstResult);
+            if (populates.length) {
+              await modelInstance.populateFields([result], populates);
+            }
+            for (const manuallySetField of manuallySetFields) {
+              result[manuallySetField.propertyName] = manuallySetField.value;
+            }
+            return await resolve(result);
+          }
+          return await resolve(null);
+        } catch (ex) {
+          const typedException = ex;
+          if (typedException.stack) {
+            typedException.stack += `
+${stack ?? ""}`;
+          } else {
+            typedException.stack = stack;
+          }
+          return reject(typedException);
+        }
+      }
+    };
+  }
+  /**
+   * Gets a collection of objects
+   * @param {object} [args] - Arguments
+   * @param {string[]} [args.select] - Array of model property names to return from the query.
+   * @param {object} [args.where] - Object representing the where query
+   * @param {string|object} [args.sort] - Property name(s) to sort by
+   * @param {string|number} [args.skip] - Number of records to skip
+   * @param {string|number} [args.limit] - Number of results to return
+   */
+  find(args = {}) {
+    const { stack } = new Error(`${this.model.name}.find()`);
+    let select;
+    let where = {};
+    let sort = null;
+    let skip = null;
+    let limit = null;
+    let poolOverride;
+    for (const [name, value] of Object.entries(args)) {
+      let isWhereCriteria = false;
+      switch (name) {
+        case "select":
+          if (value) {
+            select = new Set(value);
+          }
+          break;
+        case "where":
+          where = value;
+          break;
+        case "sort":
+          sort = value;
+          break;
+        case "skip":
+          skip = value;
+          break;
+        case "limit":
+          limit = value;
+          break;
+        case "pool":
+          poolOverride = value;
+          break;
+        default:
+          select = void 0;
+          where = args;
+          sort = null;
+          skip = null;
+          limit = null;
+          isWhereCriteria = true;
+          break;
+      }
+      if (isWhereCriteria) {
+        break;
+      }
+    }
+    const populates = [];
+    const sorts = sort ? this._convertSortsToOrderBy(sort) : [];
+    const modelInstance = this;
+    return {
+      /**
+       * Filters the query
+       * @param {object} value - Object representing the where query
+       */
+      where(value) {
+        where = value;
+        return this;
+      },
+      /**
+       * Populates/hydrates relations
+       * @param {string} propertyName - Name of property to join
+       * @param {object} [options] - Populate options
+       * @param {object} [options.where] - Object representing the where query
+       * @param {string[]} [options.select] - Array of model property names to return from the query.
+       * @param {string|object} [options.sort] - Property name(s) to sort by
+       * @param {string|number} [options.skip] - Number of records to skip
+       * @param {string|number} [options.limit] - Number of results to return
+       */
+      populate(propertyName, options) {
+        if (select && !select.has(propertyName)) {
+          for (const column of modelInstance.model.columns) {
+            if (column.model && column.propertyName === propertyName) {
+              select.add(column.propertyName);
+            }
+          }
+        }
+        populates.push({
+          propertyName,
+          where: options?.where,
+          select: options?.select,
+          sort: options?.sort,
+          skip: options?.skip,
+          limit: options?.limit,
+          pool: options?.pool ?? poolOverride
+        });
+        return this;
+      },
+      /**
+       * Sorts the query
+       * @param {string|string[]|object} [value]
+       */
+      sort(value) {
+        if (value) {
+          sorts.push(...modelInstance._convertSortsToOrderBy(value));
+        }
+        return this;
+      },
+      /**
+       * Limits results returned by the query
+       * @param {number} value
+       */
+      limit(value) {
+        limit = value;
+        return this;
+      },
+      /**
+       * Skips records returned by the query
+       * @param {number} value
+       */
+      skip(value) {
+        skip = value;
+        return this;
+      },
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars
+      UNSAFE_withOriginalFieldType(_propertyName) {
+        return this;
+      },
+      /**
+       * Pages records returned by the query
+       * @param {number} [page=1] - Page to return - Starts at 1
+       * @param {number} [limit=10] - Number of records to return
+       */
+      paginate({ page = 1, limit: paginateLimit = 10 }) {
+        const safePage = Math.max(page, 1);
+        return this.skip(safePage * paginateLimit - paginateLimit).limit(paginateLimit);
+      },
+      async then(resolve, reject) {
+        try {
+          if (___default.isString(where)) {
+            return await reject(new Error("The query cannot be a string, it must be an object"));
+          }
+          const { query, params } = getSelectQueryAndParams({
+            repositoriesByModelNameLowered: modelInstance._repositoriesByModelNameLowered,
+            model: modelInstance.model,
+            select: select ? Array.from(select) : void 0,
+            where,
+            sorts,
+            skip: skip ?? 0,
+            limit: limit ?? 0
+          });
+          const pool = poolOverride ?? modelInstance._readonlyPool;
+          const results = await pool.query(query, params);
+          const entities = modelInstance._buildInstances(results.rows);
+          if (populates.length) {
+            await modelInstance.populateFields(entities, populates);
+          }
+          return await resolve(entities);
+        } catch (ex) {
+          const typedException = ex;
+          if (typedException.stack) {
+            typedException.stack += `
+${stack ?? ""}`;
+          } else {
+            typedException.stack = stack;
+          }
+          return reject(typedException);
+        }
+      }
+    };
+  }
+  /**
+   * Gets a count of rows matching the where query
+   * @param {object} [args] - Arguments
+   * @param {object} [args.where] - Object representing the where query
+   * @param {object} [args.pool] - Override the db pool to use for the query
+   * @returns {number} Number of records matching the where criteria
+   */
+  count(args = {}) {
+    const { stack } = new Error(`${this.model.name}.count()`);
+    let where = {};
+    let poolOverride;
+    for (const [name, value] of Object.entries(args)) {
+      let isWhereCriteria = false;
+      switch (name) {
+        case "where":
+          where = value;
+          break;
+        case "pool":
+          poolOverride = value;
+          break;
+        default:
+          where = args;
+          isWhereCriteria = true;
+          break;
+      }
+      if (isWhereCriteria) {
+        break;
+      }
+    }
+    const modelInstance = this;
+    return {
+      /**
+       * Filters the query
+       * @param {object} value - Object representing the where query
+       */
+      where(value) {
+        where = value;
+        return this;
+      },
+      async then(resolve, reject) {
+        try {
+          const { query, params } = getCountQueryAndParams({
+            repositoriesByModelNameLowered: modelInstance._repositoriesByModelNameLowered,
+            model: modelInstance.model,
+            where
+          });
+          const pool = poolOverride ?? modelInstance._readonlyPool;
+          const result = await pool.query(query, params);
+          const firstResult = ___default.first(result.rows);
+          const originalValue = firstResult ? firstResult.count : 0;
+          return await resolve(Number(originalValue));
+        } catch (ex) {
+          const typedException = ex;
+          if (typedException.stack) {
+            typedException.stack += `
+${stack ?? ""}`;
+          } else {
+            typedException.stack = stack;
+          }
+          return reject(typedException);
+        }
+      }
+    };
+  }
+  _buildInstance(row) {
+    if (___default.isNil(row)) {
+      return row;
+    }
+    const instance = new this._type();
+    Object.assign(instance, row);
+    for (const name of this._floatProperties) {
+      const originalValue = row[name];
+      if (!___default.isNil(originalValue) && typeof originalValue === "string") {
+        try {
+          const value = Number(originalValue);
+          if (___default.isFinite(value) && value.toString() === originalValue) {
+            instance[name] = value;
+          }
+        } catch {
+        }
+      }
+    }
+    for (const name of this._intProperties) {
+      const originalValue = row[name];
+      if (!___default.isNil(originalValue) && typeof originalValue === "string") {
+        try {
+          const value = Number(originalValue);
+          if (___default.isFinite(value) && value.toString() === originalValue) {
+            const valueAsInt = ___default.toInteger(value);
+            if (Number.isSafeInteger(valueAsInt)) {
+              instance[name] = valueAsInt;
+            }
+          }
+        } catch {
+        }
+      }
+    }
+    return instance;
+  }
+  _buildInstances(rows) {
+    if (___default.isNil(rows)) {
+      return [];
+    }
+    return rows.map((row) => this._buildInstance(row));
+  }
+  // eslint-disable-next-line class-methods-use-this
+  _convertSortsToOrderBy(sorts) {
+    const result = [];
+    if (sorts) {
+      if (Array.isArray(sorts)) {
+        for (const sort of sorts) {
+          const parts = sort.trim().split(" ");
+          const propertyName = parts.shift();
+          result.push({
+            propertyName,
+            descending: /desc/i.test(parts.join(""))
+          });
+        }
+      } else if (___default.isString(sorts)) {
+        for (const sort of sorts.split(",")) {
+          const parts = sort.trim().split(" ");
+          const propertyName = parts.shift();
+          result.push({
+            propertyName,
+            descending: /desc/i.test(parts.join(""))
+          });
+        }
+      } else if (___default.isObject(sorts)) {
+        for (const [propertyName, orderValue] of Object.entries(sorts)) {
+          let descending = false;
+          const order = orderValue;
+          if (order && (order === -1 || /desc/i.test(`${order}`))) {
+            descending = true;
+          }
+          result.push({
+            propertyName,
+            descending
+          });
+        }
+      }
+    }
+    return result;
+  }
+  // NOTE: This will mutate `entities`
+  async populateFields(entities, populates) {
+    if (!entities.length) {
+      return;
+    }
+    const populateQueries = [];
+    for (const populate of populates) {
+      const column = this.model.columnsByPropertyName[populate.propertyName];
+      if (!column) {
+        throw new Error(`Unable to find ${populate.propertyName} on ${this.model.name} model for populating.`);
+      }
+      const modelColumn = column;
+      const collectionColumn = column;
+      if (modelColumn.model) {
+        populateQueries.push(this.populateSingleAssociation(entities, populate, modelColumn));
+      } else if (collectionColumn.collection) {
+        const populateRepository = this._repositoriesByModelNameLowered[collectionColumn.collection.toLowerCase()];
+        if (!populateRepository) {
+          throw new Error(`Unable to find populate repository for collection by name ${collectionColumn.collection}. From ${column.target}#${populate.propertyName}`);
+        }
+        const { primaryKeyColumn } = this.model;
+        if (!primaryKeyColumn) {
+          throw new Error(`Unable to populate ${column.target}#${column.propertyName}. There is no primary key defined in ${this.model.name}`);
+        }
+        const entityIds = /* @__PURE__ */ new Set();
+        for (const entity of entities) {
+          const id = entity[primaryKeyColumn.propertyName];
+          if (___default.isNil(id)) {
+            throw new Error(`Primary key (${primaryKeyColumn.propertyName}) has no value for entity ${column.target}.`);
+          }
+          entityIds.add(id);
+        }
+        if (collectionColumn.through) {
+          const populateModelPrimaryKeyColumn = populateRepository.model.primaryKeyColumn;
+          if (!populateModelPrimaryKeyColumn) {
+            throw new Error(
+              `Unable to populate ${collectionColumn.collection} objects from ${column.target}#${column.propertyName}. There is no primary key defined in ${collectionColumn.collection}`
+            );
+          }
+          populateQueries.push(
+            this.populateManyManyCollection(
+              entities,
+              primaryKeyColumn.propertyName,
+              Array.from(entityIds),
+              populateModelPrimaryKeyColumn.propertyName,
+              populate,
+              collectionColumn,
+              populateRepository
+            )
+          );
+        } else {
+          populateQueries.push(this.populateOneManyCollection(entities, primaryKeyColumn.propertyName, Array.from(entityIds), populate, collectionColumn, populateRepository));
+        }
+      }
+    }
+    if (populateQueries.length) {
+      await Promise.all(populateQueries);
+    }
+  }
+  async populateSingleAssociation(entities, populate, column) {
+    const populateRepository = this._repositoriesByModelNameLowered[column.model.toLowerCase()];
+    if (!populateRepository) {
+      throw new Error(`Unable to find populate repository by entity name: ${column.model}. From ${column.target}#${column.propertyName}`);
+    }
+    if (!populateRepository.model.primaryKeyColumn) {
+      throw new Error(`Unable to populate ${column.model} from ${column.target}#${column.propertyName}. There is no primary key defined in ${column.model}`);
+    }
+    const propertyName = populate.propertyName;
+    const populateIds = /* @__PURE__ */ new Set();
+    for (const entity of entities) {
+      const populateId = entity[propertyName];
+      if (populateId) {
+        populateIds.add(populateId);
+      }
+    }
+    const populateWhere = {
+      [populateRepository.model.primaryKeyColumn.propertyName]: Array.from(populateIds),
+      ...populate.where
+    };
+    const populateResults = await populateRepository.find({
+      select: populate.select,
+      where: populateWhere,
+      sort: populate.sort,
+      pool: populate.pool
+    });
+    const populateResultsById = ___default.keyBy(populateResults, populateRepository.model.primaryKeyColumn.propertyName);
+    for (const entity of entities) {
+      entity[propertyName] = populateResultsById[entity[propertyName]];
+    }
+  }
+  async populateOneManyCollection(entities, primaryKeyPropertyName, entityIds, populate, column, populateRepository) {
+    if (entities.length > 1 && populate.select && !populate.select.includes(column.via)) {
+      throw new Error(`Unable to populate "${populate.propertyName}" on ${this.model.name}. "${column.via}" is not included in select array.`);
+    }
+    const populateWhere = {
+      [column.via]: entityIds,
+      ...populate.where
+    };
+    const populateResults = await populateRepository.find({
+      select: populate.select,
+      where: populateWhere,
+      sort: populate.sort,
+      skip: populate.skip,
+      limit: populate.limit,
+      pool: populate.pool
+    });
+    if (entities.length === 1) {
+      for (const entity of entities) {
+        entity[populate.propertyName] = populateResults;
+      }
+    } else {
+      const populateResultsByEntityId = ___default.groupBy(populateResults, column.via);
+      for (const entity of entities) {
+        const id = entity[primaryKeyPropertyName];
+        entity[populate.propertyName] = populateResultsByEntityId[id] || [];
+      }
+    }
+  }
+  async populateManyManyCollection(entities, primaryKeyPropertyName, entityIds, populateModelPrimaryKeyPropertyName, populate, column, populateRepository) {
+    if (!column.through) {
+      throw new Error(`Unable to populate multi-map collection: Missing "through" value. From ${column.target}#${populate.propertyName}`);
+    }
+    const throughRepository = this._repositoriesByModelNameLowered[column.through.toLowerCase()];
+    if (!throughRepository) {
+      throw new Error(`Unable to find repository for multi-map collection: ${column.through}. From ${column.target}#${populate.propertyName}`);
+    }
+    let relatedModelColumn;
+    for (const populateModelColumn of populateRepository.model.columns) {
+      const { through } = populateModelColumn;
+      if (through && through.toLowerCase() === column.through.toLowerCase()) {
+        relatedModelColumn = populateModelColumn;
+        break;
+      }
+    }
+    if (!relatedModelColumn) {
+      throw new Error(`Unable to find property on related model for multi-map collection: ${column.through}. From ${column.target}#${populate.propertyName}`);
+    }
+    const mapRecords = await throughRepository.find({
+      select: [column.via, relatedModelColumn.via],
+      where: {
+        [column.via]: entityIds
+      },
+      pool: populate.pool
+    });
+    const populateIds = /* @__PURE__ */ new Set();
+    const populateIdsByEntityId = {};
+    for (const mapRecord of mapRecords) {
+      const entityId = mapRecord[column.via];
+      const populatedId = mapRecord[relatedModelColumn.via];
+      populateIds.add(populatedId);
+      const entityPopulateIds = populateIdsByEntityId[entityId] ?? [];
+      entityPopulateIds.push(populatedId);
+      populateIdsByEntityId[entityId] = entityPopulateIds;
+    }
+    const populateWhere = ___default.merge(
+      {
+        [populateModelPrimaryKeyPropertyName]: Array.from(populateIds)
+      },
+      populate.where
+    );
+    const populateResults = await populateRepository.find({
+      select: populate.select,
+      where: populateWhere,
+      sort: populate.sort,
+      skip: populate.skip,
+      limit: populate.limit,
+      pool: populate.pool
+    });
+    const populateResultsById = ___default.keyBy(populateResults, populateModelPrimaryKeyPropertyName);
+    for (const entity of entities) {
+      const populatedItems = [];
+      const entityId = entity[primaryKeyPropertyName];
+      const populateIdsForEntity = populateIdsByEntityId[entityId] ?? [];
+      for (const id of populateIdsForEntity) {
+        const populatedItem = populateResultsById[id];
+        if (populatedItem) {
+          populatedItems.push(populatedItem);
+        }
+      }
+      entity[populate.propertyName] = populatedItems;
+    }
+  }
+}
+
+class Repository extends ReadonlyRepository {
+  /**
+   * Creates an object using the specified values
+   * @param {object|object[]} values - Values to insert as a new object. If an array is specified, multiple rows will be inserted
+   * @param {object} [options]
+   * @param {boolean} [options.returnRecords=true] - Determines if inserted records should be returned
+   * @param {string[]} [options.returnSelect] - Array of model property names to return from the query.
+   * @param {object} [options.onConflict] - Options to handle conflicts due to a unique constraint or exclusion constraint error during insert
+   * @returns {object|object[]|void} Return value from the db
+   */
+  async create(values, options) {
+    if (this.model.readonly) {
+      throw new Error(`${this.model.name} is readonly.`);
+    }
+    if (___default.isArray(values) && !values.length) {
+      return [];
+    }
+    if (this._type.beforeCreate) {
+      if (Array.isArray(values)) {
+        values = await Promise.all(values.map((value) => this._type.beforeCreate ? this._type.beforeCreate(value) : Promise.resolve()));
+      } else {
+        values = await this._type.beforeCreate(values);
+      }
+    }
+    let returnRecords = true;
+    let returnSelect;
+    if (options) {
+      if (options.returnRecords === false) {
+        returnRecords = false;
+      } else if (options.returnSelect) {
+        returnSelect = options.returnSelect;
+      }
+    }
+    const { query, params } = getInsertQueryAndParams({
+      repositoriesByModelNameLowered: this._repositoriesByModelNameLowered,
+      model: this.model,
+      values,
+      returnRecords,
+      returnSelect,
+      onConflict: options?.onConflict
+    });
+    const results = await this._pool.query(query, params);
+    if (returnRecords) {
+      if (___default.isArray(values)) {
+        return this._buildInstances(results.rows);
+      }
+      const firstResult = ___default.first(results.rows);
+      if (firstResult) {
+        return this._buildInstance(firstResult);
+      }
+      throw new Error("Unknown error getting created rows back from the database");
+    }
+    return void 0;
+  }
+  /**
+   * Updates object(s) matching the where query, with the specified values
+   * @param {object} where - Object representing the where query
+   * @param {object} values - Values to update
+   * @param {object} [options]
+   * @param {boolean} [options.returnRecords=true] - Determines if inserted records should be returned
+   * @param {string[]} [options.returnSelect] - Array of model property names to return from the query.
+   * @returns {object[]|void} Return values from the db or `true` if returnRecords=false
+   */
+  async update(where, values, options) {
+    if (this.model.readonly) {
+      throw new Error(`${this.model.name} is readonly.`);
+    }
+    if (___default.isString(where)) {
+      throw new Error("The query cannot be a string, it must be an object");
+    }
+    if (this._type.beforeUpdate) {
+      values = await this._type.beforeUpdate(values);
+    }
+    let returnRecords = true;
+    let returnSelect;
+    if (options) {
+      if (options.returnRecords === false) {
+        returnRecords = false;
+      } else if (options.returnSelect) {
+        returnSelect = options.returnSelect;
+      }
+    }
+    const { query, params } = getUpdateQueryAndParams({
+      repositoriesByModelNameLowered: this._repositoriesByModelNameLowered,
+      model: this.model,
+      where,
+      values,
+      returnRecords,
+      returnSelect
+    });
+    const results = await this._pool.query(query, params);
+    if (returnRecords) {
+      return this._buildInstances(results.rows);
+    }
+    return void 0;
+  }
+  /**
+   * Destroys object(s) matching the where query
+   * @param {object} where - Object representing the where query
+   * @param {object} [options]
+   * @param {boolean} [options.returnRecords=false] - Determines if inserted records should be returned
+   * @param {string[]} [options.returnSelect] - Array of model property names to return from the query.
+   * @returns {object[]|void} `void` or records affected if returnRecords=true
+   */
+  destroy(where = {}, options) {
+    if (this.model.readonly) {
+      throw new Error(`${this.model.name} is readonly.`);
+    }
+    const { stack } = new Error(`${this.model.name}.destroy()`);
+    const modelInstance = this;
+    const returnSelect = options?.returnSelect;
+    const returnRecords = options?.returnRecords ?? !!returnSelect;
+    return {
+      /**
+       * Filters the query
+       * @param {object} value - Object representing the where query
+       */
+      where(value) {
+        where = value;
+        return this;
+      },
+      async then(resolve, reject) {
+        if (___default.isString(where)) {
+          return reject(new Error("The query cannot be a string, it must be an object"));
+        }
+        try {
+          const { query, params } = getDeleteQueryAndParams({
+            repositoriesByModelNameLowered: modelInstance._repositoriesByModelNameLowered,
+            model: modelInstance.model,
+            where,
+            returnRecords,
+            returnSelect
+          });
+          const result = await modelInstance._pool.query(query, params);
+          if (returnRecords) {
+            return await resolve(modelInstance._buildInstances(result.rows));
+          }
+          return await resolve();
+        } catch (ex) {
+          const typedException = ex;
+          if (typedException.stack) {
+            typedException.stack = `${typedException.stack}
+
+${stack}`;
+          } else {
+            typedException.stack = stack;
+          }
+          return reject(typedException);
+        }
+      }
+    };
+  }
+}
+
+function column(dbColumnNameOrOptions, options) {
+  return function columnDecorator(object, propertyName) {
+    if (!dbColumnNameOrOptions) {
+      dbColumnNameOrOptions = ___default.snakeCase(propertyName);
+    }
+    let dbColumnName;
+    if (typeof dbColumnNameOrOptions === "string") {
+      dbColumnName = dbColumnNameOrOptions;
+    } else {
+      options = dbColumnNameOrOptions;
+    }
+    if (!options) {
+      options = {};
+    }
+    if (!dbColumnName) {
+      dbColumnName = options.name ?? ___default.snakeCase(propertyName);
+    }
+    const metadataStorage = getMetadataStorage();
+    const columnCollectionOptions = options;
+    if (columnCollectionOptions.collection || columnCollectionOptions.via) {
+      if (!columnCollectionOptions.collection) {
+        throw new Error("Unable to determine collection value. Please try specifying values as a strings to avoid circular dependency issues.");
+      }
+      metadataStorage.columns.push(
+        new ColumnCollectionMetadata({
+          target: object.constructor.name,
+          name: dbColumnName,
+          propertyName,
+          required: columnCollectionOptions.required,
+          collection: columnCollectionOptions.collection,
+          through: columnCollectionOptions.through,
+          via: columnCollectionOptions.via
+        })
+      );
+      return;
+    }
+    const columnModelOptions = options;
+    if (columnModelOptions.model) {
+      metadataStorage.columns.push(
+        new ColumnModelMetadata({
+          target: object.constructor.name,
+          name: dbColumnName,
+          propertyName,
+          required: columnModelOptions.required,
+          model: columnModelOptions.model
+        })
+      );
+      return;
+    }
+    const columnTypeOptions = options;
+    metadataStorage.columns.push(
+      new ColumnTypeMetadata({
+        target: object.constructor.name,
+        name: dbColumnName,
+        propertyName,
+        required: columnTypeOptions.required,
+        type: columnTypeOptions.type,
+        defaultsTo: columnTypeOptions.defaultsTo,
+        enum: columnTypeOptions.enum,
+        maxLength: columnTypeOptions.maxLength
+      })
+    );
+  };
+}
+
+function createDateColumn(dbColumnNameOrOptions, options) {
+  return function createDateColumnDecorator(object, propertyName) {
+    const metadataStorage = getMetadataStorage();
+    let dbColumnName;
+    if (typeof dbColumnNameOrOptions === "string") {
+      dbColumnName = dbColumnNameOrOptions;
+    } else {
+      options = dbColumnNameOrOptions;
+    }
+    if (dbColumnNameOrOptions) {
+      if (!options) {
+        options = {};
+      }
+      if (!dbColumnName) {
+        dbColumnName = options.name ?? ___default.snakeCase(propertyName);
+      }
+      metadataStorage.columns.push(
+        new ColumnTypeMetadata({
+          target: object.constructor.name,
+          name: dbColumnName,
+          propertyName,
+          createDate: true,
+          required: options.required,
+          type: options.type
+        })
+      );
+    } else {
+      metadataStorage.columnModifiers.push({
+        target: object.constructor.name,
+        name: dbColumnName ?? ___default.snakeCase(propertyName),
+        propertyName,
+        createDate: true,
+        required: options ? options.required : void 0,
+        type: options ? options.type : "datetime"
+      });
+    }
+  };
+}
+
+function primaryColumn(dbColumnNameOrOptions, options) {
+  return function primaryColumnDecorator(object, propertyName) {
+    let dbColumnName;
+    if (typeof dbColumnNameOrOptions === "string") {
+      dbColumnName = dbColumnNameOrOptions;
+    } else {
+      options = dbColumnNameOrOptions;
+    }
+    if (dbColumnNameOrOptions) {
+      if (!options) {
+        options = {};
+      }
+      if (!dbColumnName) {
+        dbColumnName = options.name ?? ___default.snakeCase(propertyName);
+      }
+      const { type } = options;
+      const { model } = options;
+      const metadataStorage = getMetadataStorage();
+      if (model) {
+        metadataStorage.columns.push(
+          new ColumnModelMetadata({
+            target: object.constructor.name,
+            name: dbColumnName,
+            propertyName,
+            primary: true,
+            required: options.required,
+            model
+          })
+        );
+      } else {
+        metadataStorage.columns.push(
+          new ColumnTypeMetadata({
+            target: object.constructor.name,
+            name: dbColumnName,
+            propertyName,
+            primary: true,
+            required: options.required,
+            type
+          })
+        );
+      }
+    } else {
+      const metadataStorage = getMetadataStorage();
+      metadataStorage.columnModifiers.push({
+        target: object.constructor.name,
+        name: dbColumnName ?? ___default.snakeCase(propertyName),
+        propertyName,
+        primary: true,
+        required: options ? options.required : void 0,
+        type: options ? options.type : void 0,
+        model: options ? options.model : void 0
+      });
+    }
+  };
+}
+
+function table(dbNameOrTableOptions, options) {
+  return function tableDecorator(classObject) {
+    const className = classObject.name;
+    let dbTableName;
+    if (typeof dbNameOrTableOptions === "string") {
+      dbTableName = dbNameOrTableOptions;
+    } else {
+      options = dbNameOrTableOptions;
+    }
+    if (!options) {
+      options = {};
+    }
+    if (!options.name) {
+      options.name = dbTableName ?? ___default.snakeCase(className);
+    }
+    const metadataStorage = getMetadataStorage();
+    const modelMetadata = new ModelMetadata({
+      name: className,
+      type: classObject,
+      tableName: options.name,
+      readonly: options.readonly ?? false,
+      connection: options.connection
+    });
+    metadataStorage.models.push(modelMetadata);
+  };
+}
+
+function updateDateColumn(dbColumnNameOrOptions, options) {
+  return function updateDateColumnDecorator(object, propertyName) {
+    let dbColumnName;
+    if (typeof dbColumnNameOrOptions === "string") {
+      dbColumnName = dbColumnNameOrOptions;
+    } else {
+      options = dbColumnNameOrOptions;
+    }
+    if (dbColumnNameOrOptions) {
+      if (!options) {
+        options = {};
+      }
+      if (!dbColumnName) {
+        dbColumnName = options.name ?? ___default.snakeCase(propertyName);
+      }
+      const metadataStorage = getMetadataStorage();
+      metadataStorage.columns.push(
+        new ColumnTypeMetadata({
+          target: object.constructor.name,
+          name: dbColumnName,
+          propertyName,
+          updateDate: true,
+          required: options.required,
+          type: options.type
+        })
+      );
+    } else {
+      const metadataStorage = getMetadataStorage();
+      metadataStorage.columnModifiers.push({
+        target: object.constructor.name,
+        name: dbColumnName ?? ___default.snakeCase(propertyName),
+        propertyName,
+        updateDate: true,
+        required: options ? options.required : void 0,
+        type: options ? options.type : "datetime"
+      });
+    }
+  };
+}
+
+function versionColumn(dbColumnNameOrOptions, options) {
+  return function versionColumnDecorator(object, propertyName) {
+    let dbColumnName;
+    if (typeof dbColumnNameOrOptions === "string") {
+      dbColumnName = dbColumnNameOrOptions;
+    } else {
+      options = dbColumnNameOrOptions;
+    }
+    if (dbColumnNameOrOptions) {
+      if (!options) {
+        options = {};
+      }
+      if (!dbColumnName) {
+        dbColumnName = options.name ?? ___default.snakeCase(propertyName);
+      }
+      const metadataStorage = getMetadataStorage();
+      metadataStorage.columns.push(
+        new ColumnTypeMetadata({
+          target: object.constructor.name,
+          name: dbColumnName,
+          propertyName,
+          version: true,
+          required: options.required,
+          type: options.type
+        })
+      );
+    } else {
+      const metadataStorage = getMetadataStorage();
+      metadataStorage.columnModifiers.push({
+        target: object.constructor.name,
+        name: dbColumnName ?? ___default.snakeCase(propertyName),
+        propertyName,
+        version: true,
+        required: options ? options.required : void 0,
+        type: options ? options.type : void 0
+      });
+    }
+  };
+}
+
+class Entity {
+  static beforeCreate(values) {
+    return values;
+  }
+  static beforeUpdate(values) {
+    return values;
+  }
+}
+
+function getInheritanceTree(model) {
+  const tree = [model];
+  function getRecursivePrototypesOf(parentEntity) {
+    const proto = Object.getPrototypeOf(parentEntity);
+    if (proto && proto.name && proto.name !== "Function") {
+      tree.unshift(proto);
+      getRecursivePrototypesOf(proto);
+    }
+  }
+  getRecursivePrototypesOf(model);
+  return tree;
+}
+function initialize({ models, pool, readonlyPool = pool, connections = {}, expose }) {
+  if (!models.length) {
+    throw new Error("Models need to be specified to read all model information from decorators");
+  }
+  const inheritanceTreesByModelName = {};
+  const modelNames = [];
+  for (const model of models) {
+    inheritanceTreesByModelName[model.name] = getInheritanceTree(model);
+    modelNames.push(model.name);
+  }
+  const metadataStorage = getMetadataStorage();
+  const modelMetadataByModelName = {};
+  for (const model of metadataStorage.models) {
+    modelMetadataByModelName[model.name] = model;
+  }
+  const columnsByPropertyNameForModel = {};
+  for (const column of metadataStorage.columns) {
+    const columns = columnsByPropertyNameForModel[column.target] ?? {};
+    columns[column.propertyName] = column;
+    columnsByPropertyNameForModel[column.target] = columns;
+  }
+  const columnModifiersByPropertyNameForModel = {};
+  for (const columnModifier of metadataStorage.columnModifiers) {
+    const columnModifiersForModel = columnModifiersByPropertyNameForModel[columnModifier.target] ?? {};
+    const columnModifiersForProperty = columnModifiersForModel[columnModifier.propertyName] ?? [];
+    columnModifiersForProperty.push(columnModifier);
+    columnModifiersForModel[columnModifier.propertyName] = columnModifiersForProperty;
+    columnModifiersByPropertyNameForModel[columnModifier.target] = columnModifiersForModel;
+  }
+  for (const model of models) {
+    let modelMetadata;
+    let inheritedColumnsByPropertyName = {};
+    const inheritedColumnModifiersByPropertyName = /* @__PURE__ */ new Map();
+    for (const inheritedClass of inheritanceTreesByModelName[model.name] ?? []) {
+      modelMetadata = modelMetadataByModelName[inheritedClass.name] ?? modelMetadata;
+      const columnsByPropertyName = columnsByPropertyNameForModel[inheritedClass.name] ?? {};
+      inheritedColumnsByPropertyName = {
+        ...inheritedColumnsByPropertyName,
+        ...columnsByPropertyName
+      };
+      for (const [propertyName] of Object.entries(columnsByPropertyName)) {
+        inheritedColumnModifiersByPropertyName.delete(propertyName);
+      }
+      const columnModifiersByPropertyName = columnModifiersByPropertyNameForModel[inheritedClass.name] ?? {};
+      for (const [propertyName, columnModifiers] of Object.entries(columnModifiersByPropertyName)) {
+        inheritedColumnModifiersByPropertyName.set(propertyName, [...inheritedColumnModifiersByPropertyName.get(propertyName) ?? [], ...columnModifiers ?? []]);
+      }
+    }
+    if (!modelMetadata) {
+      throw new Error(`Unable to find @table() on ${model.name}`);
+    }
+    modelMetadataByModelName[model.name] = new ModelMetadata({
+      ...modelMetadata,
+      name: model.name,
+      type: model
+    });
+    columnsByPropertyNameForModel[model.name] = inheritedColumnsByPropertyName;
+    columnModifiersByPropertyNameForModel[model.name] = Object.fromEntries(inheritedColumnModifiersByPropertyName);
+  }
+  for (const [modelName, columnModifiersByPropertyName] of Object.entries(columnModifiersByPropertyNameForModel)) {
+    const columnsByPropertyName = columnsByPropertyNameForModel[modelName] ?? {};
+    for (const [propertyName, columnModifiers] of Object.entries(columnModifiersByPropertyName)) {
+      const column = columnsByPropertyName[propertyName];
+      if (column) {
+        for (const columnModifier of columnModifiers) {
+          Object.assign(column, ___default.omit(columnModifier, ["target", "name", "propertyName", "type", "model"]));
+        }
+      } else {
+        let columnDetails = {
+          target: modelName,
+          propertyName
+        };
+        for (const columnModifier of columnModifiers) {
+          columnDetails = {
+            ...columnDetails,
+            ...columnModifier
+          };
+        }
+        if (!columnDetails.name) {
+          throw new Error(`Missing column name for ${modelName}#${propertyName}`);
+        }
+        if (!columnDetails.type && !columnDetails.model) {
+          throw new Error(`Missing column type for ${modelName}#${propertyName}`);
+        }
+        if (columnDetails.model) {
+          columnsByPropertyName[propertyName] = new ColumnModelMetadata({
+            ...columnDetails,
+            name: columnDetails.name,
+            model: columnDetails.model
+          });
+        } else if (columnDetails.type) {
+          columnsByPropertyName[propertyName] = new ColumnTypeMetadata({
+            ...columnDetails,
+            name: columnDetails.name,
+            type: columnDetails.type
+          });
+        }
+      }
+    }
+    columnsByPropertyNameForModel[modelName] = columnsByPropertyName;
+  }
+  const repositoriesByModelNameLowered = {};
+  const repositoriesByModelName = {};
+  for (const modelName of modelNames) {
+    const model = modelMetadataByModelName[modelName];
+    if (!model) {
+      throw new Error(`Unable to find @table() on ${modelName}`);
+    }
+    const columnsByPropertyName = columnsByPropertyNameForModel[modelName];
+    if (!columnsByPropertyName) {
+      throw new Error(`Did not find any columns decorated with @column. Model: ${modelName}`);
+    }
+    model.columns = Object.values(columnsByPropertyName);
+    let modelPool = pool;
+    let modelReadonlyPool = readonlyPool;
+    if (model.connection) {
+      const modelConnection = connections[model.connection];
+      if (!modelConnection) {
+        throw new Error(`Unable to find connection (${model.connection}) for entity: ${model.name}`);
+      }
+      modelPool = modelConnection.pool || pool;
+      modelReadonlyPool = modelConnection.readonlyPool ?? modelPool;
+    }
+    let repository;
+    if (model.readonly) {
+      repository = new ReadonlyRepository({
+        modelMetadata: model,
+        type: model.type,
+        repositoriesByModelNameLowered,
+        pool: modelPool,
+        readonlyPool: modelReadonlyPool
+      });
+      repositoriesByModelNameLowered[model.name.toLowerCase()] = repository;
+      repositoriesByModelName[model.name] = repository;
+    } else {
+      repository = new Repository({
+        modelMetadata: model,
+        type: model.type,
+        repositoriesByModelNameLowered,
+        pool: modelPool,
+        readonlyPool: modelReadonlyPool
+      });
+      repositoriesByModelNameLowered[model.name.toLowerCase()] = repository;
+      repositoriesByModelName[model.name] = repository;
+    }
+    if (expose) {
+      expose(repository, model);
+    }
+  }
+  return repositoriesByModelName;
+}
+
+exports.ColumnBaseMetadata = ColumnBaseMetadata;
+exports.ColumnCollectionMetadata = ColumnCollectionMetadata;
+exports.ColumnModelMetadata = ColumnModelMetadata;
+exports.ColumnTypeMetadata = ColumnTypeMetadata;
+exports.Entity = Entity;
+exports.ModelMetadata = ModelMetadata;
+exports.ReadonlyRepository = ReadonlyRepository;
+exports.Repository = Repository;
+exports.column = column;
+exports.createDateColumn = createDateColumn;
+exports.getMetadataStorage = getMetadataStorage;
+exports.initialize = initialize;
+exports.primaryColumn = primaryColumn;
+exports.table = table;
+exports.updateDateColumn = updateDateColumn;
+exports.versionColumn = versionColumn;