bigal 13.0.0-beta4 → 13.0.0-beta6

package/dist/index.mjs

@@ -1,7 +1,359 @@
 import _ from 'lodash';
-import { getMetadataStorage, ModelMetadata, ColumnModelMetadata, ColumnTypeMetadata } from './metadata/index.mjs';
-export { ColumnBaseMetadata, ColumnCollectionMetadata } from './metadata/index.mjs';
-export { column, createDateColumn, primaryColumn, table, updateDateColumn, versionColumn } from './decorators/index.mjs';
+
+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 ?? _.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;
@@ -1810,6 +2162,273 @@ ${stack}`;
   }
 }
 
+function column(dbColumnNameOrOptions, options) {
+  return function columnDecorator(object, propertyName) {
+    if (!dbColumnNameOrOptions) {
+      dbColumnNameOrOptions = _.snakeCase(propertyName);
+    }
+    let dbColumnName;
+    if (typeof dbColumnNameOrOptions === "string") {
+      dbColumnName = dbColumnNameOrOptions;
+    } else {
+      options = dbColumnNameOrOptions;
+    }
+    if (!options) {
+      options = {};
+    }
+    if (!dbColumnName) {
+      dbColumnName = options.name ?? _.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 ?? _.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 ?? _.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 ?? _.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 ?? _.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 ?? _.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 ?? _.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 ?? _.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 ?? _.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 ?? _.snakeCase(propertyName),
+        propertyName,
+        version: true,
+        required: options ? options.required : void 0,
+        type: options ? options.type : void 0
+      });
+    }
+  };
+}
+
 class Entity {
   static beforeCreate(values) {
     return values;
@@ -1983,4 +2602,4 @@ function initialize({ models, pool, readonlyPool = pool, connections = {}, expos
   return repositoriesByModelName;
 }
 
-export { ColumnModelMetadata, ColumnTypeMetadata, Entity, ModelMetadata, ReadonlyRepository, Repository, getMetadataStorage, initialize };
+export { ColumnBaseMetadata, ColumnCollectionMetadata, ColumnModelMetadata, ColumnTypeMetadata, Entity, ModelMetadata, ReadonlyRepository, Repository, column, createDateColumn, getMetadataStorage, initialize, primaryColumn, table, updateDateColumn, versionColumn };

package/package.json

@@ -1,32 +1,12 @@
 {
   "name": "bigal",
-  "version": "13.0.0-beta4",
+  "version": "13.0.0-beta6",
   "description": "A fast and lightweight orm for postgres and node.js, written in typescript.",
   "main": "./dist/index.cjs",
   "module": "./dist/index.mjs",
   "types": "./dist/index.d.ts",
   "type": "module",
   "exports": {
-    "./decorators": {
-      "import": {
-        "types": "./dist/decorators/index.d.ts",
-        "default": "./dist/decorators/index.mjs"
-      },
-      "require": {
-        "types": "./dist/decorators/index.d.cts",
-        "default": "./dist/decorators/index.cjs"
-      }
-    },
-    "./metadata": {
-      "import": {
-        "types": "./dist/metadata/index.d.ts",
-        "default": "./dist/metadata/index.mjs"
-      },
-      "require": {
-        "types": "./dist/metadata/index.d.cts",
-        "default": "./dist/metadata/index.cjs"
-      }
-    },
     ".": {
       "import": {
         "types": "./dist/index.d.ts",
@@ -38,13 +18,6 @@
       }
     }
   },
-  "typesVersions": {
-    "*": {
-      "*": [
-        "./dist/*"
-      ]
-    }
-  },
   "keywords": [
     "orm",
     "postgres",