bigal 13.0.0-beta3 → 13.0.0-beta5

package/dist/index.cjs

@@ -1,13 +1,366 @@
 'use strict';
 
 const _ = require('lodash');
-const metadata_index = require('./metadata/index.cjs');
-const decorators_index = require('./decorators/index.cjs');
 
 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) => {
@@ -1815,6 +2168,273 @@ ${stack}`;
   }
 }
 
+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;
@@ -1846,7 +2466,7 @@ function initialize({ models, pool, readonlyPool = pool, connections = {}, expos
     inheritanceTreesByModelName[model.name] = getInheritanceTree(model);
     modelNames.push(model.name);
   }
-  const metadataStorage = metadata_index.getMetadataStorage();
+  const metadataStorage = getMetadataStorage();
   const modelMetadataByModelName = {};
   for (const model of metadataStorage.models) {
     modelMetadataByModelName[model.name] = model;
@@ -1887,7 +2507,7 @@ function initialize({ models, pool, readonlyPool = pool, connections = {}, expos
     if (!modelMetadata) {
       throw new Error(`Unable to find @table() on ${model.name}`);
     }
-    modelMetadataByModelName[model.name] = new metadata_index.ModelMetadata({
+    modelMetadataByModelName[model.name] = new ModelMetadata({
       ...modelMetadata,
       name: model.name,
       type: model
@@ -1921,13 +2541,13 @@ function initialize({ models, pool, readonlyPool = pool, connections = {}, expos
           throw new Error(`Missing column type for ${modelName}#${propertyName}`);
         }
         if (columnDetails.model) {
-          columnsByPropertyName[propertyName] = new metadata_index.ColumnModelMetadata({
+          columnsByPropertyName[propertyName] = new ColumnModelMetadata({
             ...columnDetails,
             name: columnDetails.name,
             model: columnDetails.model
           });
         } else if (columnDetails.type) {
-          columnsByPropertyName[propertyName] = new metadata_index.ColumnTypeMetadata({
+          columnsByPropertyName[propertyName] = new ColumnTypeMetadata({
             ...columnDetails,
             name: columnDetails.name,
             type: columnDetails.type
@@ -1988,19 +2608,19 @@ function initialize({ models, pool, readonlyPool = pool, connections = {}, expos
   return repositoriesByModelName;
 }
 
-exports.ColumnBaseMetadata = metadata_index.ColumnBaseMetadata;
-exports.ColumnCollectionMetadata = metadata_index.ColumnCollectionMetadata;
-exports.ColumnModelMetadata = metadata_index.ColumnModelMetadata;
-exports.ColumnTypeMetadata = metadata_index.ColumnTypeMetadata;
-exports.ModelMetadata = metadata_index.ModelMetadata;
-exports.getMetadataStorage = metadata_index.getMetadataStorage;
-exports.column = decorators_index.column;
-exports.createDateColumn = decorators_index.createDateColumn;
-exports.primaryColumn = decorators_index.primaryColumn;
-exports.table = decorators_index.table;
-exports.updateDateColumn = decorators_index.updateDateColumn;
-exports.versionColumn = decorators_index.versionColumn;
+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;