@nocobase/database 0.9.0-alpha.2 → 0.9.1-alpha.1

package/src/fields/field.ts

@@ -12,6 +12,7 @@ import { Collection } from '../collection';
 import { Database } from '../database';
 import { InheritedCollection } from '../inherited-collection';
 import { ModelEventTypes } from '../types';
+import { snakeCase } from '../utils';
 
 export interface FieldContext {
   database: Database;
@@ -39,9 +40,9 @@ export abstract class Field {
   [key: string]: any;
 
   constructor(options?: any, context?: FieldContext) {
-    this.context = context;
-    this.database = context.database;
-    this.collection = context.collection;
+    this.context = context as any;
+    this.database = this.context.database;
+    this.collection = this.context.collection;
     this.options = options || {};
     this.init();
   }
@@ -89,6 +90,18 @@ export abstract class Field {
     return this.collection.removeField(this.name);
   }
 
+  columnName() {
+    if (this.options.field) {
+      return this.options.field;
+    }
+
+    if (this.database.options.underscored) {
+      return snakeCase(this.name);
+    }
+
+    return this.name;
+  }
+
   async removeFromDb(options?: QueryInterfaceOptions) {
     const attribute = this.collection.model.rawAttributes[this.name];
 
@@ -113,14 +126,19 @@ export abstract class Field {
     }
     if (this.collection.model.options.timestamps !== false) {
       // timestamps 相关字段不删除
-      if (['createdAt', 'updatedAt', 'deletedAt'].includes(this.name)) {
+      let timestampsFields = ['createdAt', 'updatedAt', 'deletedAt'];
+      if (this.database.options.underscored) {
+        timestampsFields = timestampsFields.map((field) => snakeCase(field));
+      }
+      if (timestampsFields.includes(this.columnName())) {
+        this.collection.fields.delete(this.name);
         return;
       }
     }
     // 排序字段通过 sortable 控制
     const sortable = this.collection.options.sortable;
     if (sortable) {
-      let sortField: string;
+      let sortField: any;
       if (sortable === true) {
         sortField = 'sort';
       } else if (typeof sortable === 'string') {
@@ -132,19 +150,28 @@ export abstract class Field {
         return;
       }
     }
-    if (this.options.field && this.name !== this.options.field) {
-      // field 指向的是真实的字段名，如果与 name 不一样，说明字段只是引用
-      this.remove();
-      return;
-    }
+
+    // if (this.options.field && this.name !== this.options.field) {
+    //   // field 指向的是真实的字段名，如果与 name 不一样，说明字段只是引用
+    //   this.remove();
+    //   return;
+    // }
+
+    const columnReferencesCount = _.filter(
+      this.collection.model.rawAttributes,
+      (attr) => attr.field == this.columnName(),
+    ).length;
+
     if (
-      await this.existsInDb({
+      (await this.existsInDb({
         transaction: options?.transaction,
-      })
+      })) &&
+      columnReferencesCount == 1
     ) {
       const queryInterface = this.database.sequelize.getQueryInterface();
-      await queryInterface.removeColumn(this.collection.model.tableName, this.name, options);
+      await queryInterface.removeColumn(this.collection.model.tableName, this.columnName(), options);
     }
+
     this.remove();
   }
 
@@ -154,18 +181,20 @@ export abstract class Field {
     };
     let sql;
     if (this.database.sequelize.getDialect() === 'sqlite') {
-      sql = `SELECT * from pragma_table_info('${this.collection.model.tableName}') WHERE name = '${this.name}'`;
+      sql = `SELECT * from pragma_table_info('${this.collection.model.tableName}') WHERE name = '${this.columnName()}'`;
     } else if (this.database.inDialect('mysql')) {
       sql = `
         select column_name
         from INFORMATION_SCHEMA.COLUMNS
-        where TABLE_SCHEMA='${this.database.options.database}' AND TABLE_NAME='${this.collection.model.tableName}' AND column_name='${this.name}'
+        where TABLE_SCHEMA='${this.database.options.database}' AND TABLE_NAME='${
+        this.collection.model.tableName
+      }' AND column_name='${this.columnName()}'
       `;
     } else {
       sql = `
         select column_name
         from INFORMATION_SCHEMA.COLUMNS
-        where TABLE_NAME='${this.collection.model.tableName}' AND column_name='${this.name}'
+        where TABLE_NAME='${this.collection.model.tableName}' AND column_name='${this.columnName()}'
       `;
     }
     const [rows] = await this.database.sequelize.query(sql, opts);

package/src/fields/has-many-field.ts

@@ -5,7 +5,7 @@ import {
   ForeignKeyOptions,
   HasManyOptions,
   HasManyOptions as SequelizeHasManyOptions,
-  Utils,
+  Utils
 } from 'sequelize';
 import { Collection } from '../collection';
 import { Reference } from '../features/ReferencesMap';

package/src/fields/has-one-field.ts

@@ -5,12 +5,12 @@ import {
   ForeignKeyOptions,
   HasOneOptions,
   HasOneOptions as SequelizeHasOneOptions,
-  Utils,
+  Utils
 } from 'sequelize';
 import { Collection } from '../collection';
+import { Reference } from '../features/ReferencesMap';
 import { checkIdentifier } from '../utils';
 import { BaseRelationFieldOptions, RelationField } from './relation-field';
-import { Reference } from '../features/ReferencesMap';
 
 export interface HasOneFieldOptions extends HasOneOptions {
   /**
@@ -84,11 +84,15 @@ export class HasOneField extends RelationField {
   }
 
   get foreignKey() {
-    if (this.options.foreignKey) {
-      return this.options.foreignKey;
-    }
-    const { model } = this.context.collection;
-    return Utils.camelize([model.options.name.singular, model.primaryKeyAttribute].join('_'));
+    const foreignKey = (() => {
+      if (this.options.foreignKey) {
+        return this.options.foreignKey;
+      }
+      const { model } = this.context.collection;
+      return Utils.camelize([model.options.name.singular, model.primaryKeyAttribute].join('_'));
+    })();
+
+    return foreignKey;
   }
 
   reference(association): Reference {

package/src/fields/number-field.ts

@@ -1,7 +1,11 @@
 import { DataTypes } from 'sequelize';
 import { BaseColumnFieldOptions, Field } from './field';
 
-export class IntegerField extends Field {
+abstract class NumberField extends Field {
+  
+}
+
+export class IntegerField extends NumberField {
   get dataType() {
     return DataTypes.INTEGER;
   }
@@ -11,7 +15,7 @@ export interface IntegerFieldOptions extends BaseColumnFieldOptions {
   type: 'integer';
 }
 
-export class BigIntField extends Field {
+export class BigIntField extends NumberField {
   get dataType() {
     return DataTypes.BIGINT;
   }
@@ -21,7 +25,7 @@ export interface BigIntFieldOptions extends BaseColumnFieldOptions {
   type: 'bigInt';
 }
 
-export class FloatField extends Field {
+export class FloatField extends NumberField {
   get dataType() {
     return DataTypes.FLOAT;
   }
@@ -31,7 +35,7 @@ export interface FloatFieldOptions extends BaseColumnFieldOptions {
   type: 'float';
 }
 
-export class DoubleField extends Field {
+export class DoubleField extends NumberField {
   get dataType() {
     return DataTypes.DOUBLE;
   }
@@ -41,7 +45,7 @@ export interface DoubleFieldOptions extends BaseColumnFieldOptions {
   type: 'double';
 }
 
-export class RealField extends Field {
+export class RealField extends NumberField {
   get dataType() {
     return DataTypes.REAL;
   }
@@ -51,7 +55,7 @@ export interface RealFieldOptions extends BaseColumnFieldOptions {
   type: 'real';
 }
 
-export class DecimalField extends Field {
+export class DecimalField extends NumberField {
   get dataType() {
     return DataTypes.DECIMAL;
   }

package/src/fields/sort-field.ts

@@ -53,9 +53,21 @@ export class SortField extends Field {
       transaction,
     });
 
+    const orderKey = (() => {
+      const model = this.collection.model;
+      if (model.primaryKeyAttribute) {
+        return model.primaryKeyAttribute;
+      }
+      if (model.rawAttributes['createdAt']) {
+        return 'createdAt';
+      }
+
+      throw new Error(`can not find order key for collection ${this.collection.name}`);
+    })();
+
     if (emptyCount === totalCount && emptyCount > 0) {
       const records = await this.collection.repository.find({
-        order: [this.collection.model.primaryKeyAttribute],
+        order: [orderKey],
         transaction,
       });
 

package/src/index.ts

@@ -1,9 +1,12 @@
 export { DataTypes, ModelStatic, Op, SyncOptions } from 'sequelize';
 export * from './collection';
-export * from './inherited-collection';
+export * from './collection-importer';
 export * from './database';
 export { Database as default } from './database';
+export * from './field-repository/array-field-repository';
 export * from './fields';
+export * from './filter-match';
+export * from './inherited-collection';
 export * from './magic-attribute-model';
 export * from './migration';
 export * from './mock-database';
@@ -15,6 +18,6 @@ export * from './relation-repository/multiple-relation-repository';
 export * from './relation-repository/single-relation-repository';
 export * from './repository';
 export * from './update-associations';
-export * from './collection-importer';
-export * from './filter-match';
-export * from './field-repository/array-field-repository';
+export { snakeCase } from './utils';
+export * from './value-parsers';
+

package/src/inherited-collection.ts

@@ -4,6 +4,7 @@ import { Field } from '.';
 
 export class InheritedCollection extends Collection {
   parents?: Collection[];
+
   constructor(options: CollectionOptions, context: CollectionContext) {
     if (!options.inherits) {
       throw new Error('InheritedCollection must have inherits option');

package/src/mock-database.ts

@@ -31,10 +31,12 @@ export function getConfigByEnv() {
       collate: 'utf8mb4_unicode_ci',
     },
     timezone: process.env.DB_TIMEZONE,
+    underscored: process.env.DB_UNDERSCORED === 'true',
+    schema: process.env.DB_SCHEMA !== 'public' ? process.env.DB_SCHEMA : undefined,
   };
 }
 
 export function mockDatabase(options: IDatabaseOptions = {}): MockDatabase {
-  const dbOptions = merge(getConfigByEnv(), options);
+  const dbOptions = merge(getConfigByEnv(), options) as any;
   return new MockDatabase(dbOptions);
 }

package/src/model.ts

@@ -1,9 +1,8 @@
 import lodash from 'lodash';
-import { DataTypes, Model as SequelizeModel, ModelStatic } from 'sequelize';
+import { Model as SequelizeModel, ModelStatic } from 'sequelize';
 import { Collection } from './collection';
 import { Database } from './database';
 import { Field } from './fields';
-import type { InheritedCollection } from './inherited-collection';
 import { SyncRunner } from './sync-runner';
 
 const _ = lodash;
@@ -28,6 +27,7 @@ export class Model<TModelAttributes extends {} = any, TCreationAttributes extend
   public static collection: Collection;
 
   [key: string]: any;
+
   protected _changedWithAssociations = new Set();
   protected _previousDataValuesWithAssociations = {};
 
@@ -153,6 +153,15 @@ export class Model<TModelAttributes extends {} = any, TCreationAttributes extend
   static async sync(options) {
     const model = this as any;
 
+    const _schema = model._schema;
+
+    if (_schema && _schema != 'public') {
+      await this.sequelize.query(`CREATE SCHEMA IF NOT EXISTS "${_schema}";`, {
+        raw: true,
+        transaction: options?.transaction,
+      });
+    }
+
     // fix sequelize sync with model that not have any column
     if (Object.keys(model.tableAttributes).length === 0) {
       if (this.database.inDialect('sqlite', 'mysql')) {

package/src/options-parser.ts

@@ -75,6 +75,7 @@ export class OptionsParser {
     for (const sortKey of sort) {
       let direction = sortKey.startsWith('-') ? 'DESC' : 'ASC';
       let sortField: Array<any> = sortKey.replace('-', '').split('.');
+
       if (this.database.inDialect('postgres', 'sqlite')) {
         direction = `${direction} NULLS LAST`;
       }
@@ -86,7 +87,11 @@ export class OptionsParser {
           sortField[i] = associationModel.associations[associationKey].target;
           associationModel = sortField[i];
         }
+      } else {
+        const rawField = this.model.rawAttributes[sortField[0]];
+        sortField[0] = rawField?.field || sortField[0];
       }
+
       sortField.push(direction);
       if (this.database.inDialect('mysql')) {
         orderParams.push([Sequelize.fn('ISNULL', Sequelize.col(`${this.model.name}.${sortField[0]}`))]);

package/src/relation-repository/belongs-to-many-repository.ts

@@ -62,6 +62,8 @@ export class BelongsToManyRepository extends MultipleRelationRepository implemen
     const transaction = await this.getTransaction(options);
     const association = <BelongsToMany>this.association;
 
+    const throughModel = this.throughModel();
+
     const instancesToIds = (instances) => {
       return instances.map((instance) => instance.get(this.targetKey()));
     };
@@ -69,7 +71,7 @@ export class BelongsToManyRepository extends MultipleRelationRepository implemen
     // Through Table
     const throughTableWhere: Array<any> = [
       {
-        [association.foreignKey]: this.sourceKeyValue,
+        [throughModel.rawAttributes[association.foreignKey].field]: this.sourceKeyValue,
       },
     ];
 
@@ -100,7 +102,7 @@ export class BelongsToManyRepository extends MultipleRelationRepository implemen
     }
 
     throughTableWhere.push({
-      [association.otherKey]: {
+      [throughModel.rawAttributes[association.otherKey].field]: {
         [Op.in]: ids,
       },
     });

package/src/repository.ts

@@ -11,7 +11,7 @@ import {
   Op,
   Transactionable,
   UpdateOptions as SequelizeUpdateOptions,
-  WhereOperators
+  WhereOperators,
 } from 'sequelize';
 import { Collection } from './collection';
 import { Database } from './database';
@@ -407,7 +407,12 @@ export class Repository<TModelAttributes extends {} = any, TCreationAttributes e
 
     const transaction = await this.getTransaction(options);
 
-    const guard = UpdateGuard.fromOptions(this.model, { ...options, action: 'create' });
+    const guard = UpdateGuard.fromOptions(this.model, {
+      ...options,
+      action: 'create',
+      underscored: this.collection.options.underscored,
+    });
+
     const values = guard.sanitize(options.values || {});
 
     const instance = await this.model.create<any>(values, {
@@ -476,7 +481,7 @@ export class Repository<TModelAttributes extends {} = any, TCreationAttributes e
     }
     const transaction = await this.getTransaction(options);
 
-    const guard = UpdateGuard.fromOptions(this.model, options);
+    const guard = UpdateGuard.fromOptions(this.model, { ...options, underscored: this.collection.options.underscored });
 
     const values = guard.sanitize(options.values);
 

package/src/sync-runner.ts

@@ -1,6 +1,5 @@
 import { InheritedCollection } from './inherited-collection';
 import lodash from 'lodash';
-import { Sequelize } from 'sequelize';
 
 export class SyncRunner {
   static async syncInheritModel(model: any, options: any) {
@@ -8,6 +7,8 @@ export class SyncRunner {
 
     const inheritedCollection = model.collection as InheritedCollection;
     const db = inheritedCollection.context.database;
+    const schemaName = db.options.schema || 'public';
+
     const dialect = db.sequelize.getDialect();
 
     const queryInterface = db.sequelize.getQueryInterface();
@@ -28,7 +29,10 @@ export class SyncRunner {
 
     const parentTables = parents.map((parent) => parent.model.tableName);
 
-    const tableName = model.getTableName();
+    const tableName = model.tableName;
+
+    const schemaTableName = db.utils.addSchema(tableName);
+    const quoteTableName = db.utils.quoteTable(tableName);
 
     const attributes = model.tableAttributes;
 
@@ -42,8 +46,11 @@ export class SyncRunner {
     if (childAttributes.id && childAttributes.id.autoIncrement) {
       for (const parent of parentTables) {
         const sequenceNameResult = await queryInterface.sequelize.query(
-          `SELECT column_default FROM information_schema.columns WHERE 
-          table_name='${parent}' and "column_name" = 'id';`,
+          `SELECT column_default
+           FROM information_schema.columns
+           WHERE table_name = '${parent}'
+            and table_schema = '${schemaName}'
+             and "column_name" = 'id';`,
           {
             transaction,
           },
@@ -59,13 +66,14 @@ export class SyncRunner {
           throw new Error(`Can't find sequence name of ${parent}`);
         }
 
-        const regex = new RegExp(/nextval\('("?\w+"?)\'.*\)/);
+        const regex = new RegExp(/nextval\('(.*)'::regclass\)/);
         const match = regex.exec(columnDefault);
 
         const sequenceName = match[1];
 
         const sequenceCurrentValResult = await queryInterface.sequelize.query(
-          `select last_value from ${sequenceName}`,
+          `select last_value
+           from ${sequenceName}`,
           {
             transaction,
           },
@@ -80,26 +88,25 @@ export class SyncRunner {
       }
     }
 
-    await this.createTable(tableName, childAttributes, options, model, parentTables);
+    await this.createTable(schemaTableName, childAttributes, options, model, parentTables, db);
 
     if (maxSequenceName) {
       const parentsDeep = Array.from(db.inheritanceMap.getParents(inheritedCollection.name)).map(
         (parent) => db.getCollection(parent).model.tableName,
       );
 
-      const sequenceTables = [...parentsDeep, tableName];
+      const sequenceTables = [...parentsDeep, tableName.toString()];
 
       for (const sequenceTable of sequenceTables) {
-        const queryName = Boolean(sequenceTable.match(/[A-Z]/)) ? `"${sequenceTable}"` : sequenceTable;
+        const queryName =
+          Boolean(sequenceTable.match(/[A-Z]/)) && !sequenceTable.includes(`"`) ? `"${sequenceTable}"` : sequenceTable;
 
         const idColumnQuery = await queryInterface.sequelize.query(
           `
-SELECT true
-FROM   pg_attribute 
-WHERE  attrelid = '${queryName}'::regclass  -- cast to a registered class (table)
-AND    attname = 'id'
-AND    NOT attisdropped 
-`,
+          SELECT column_name
+FROM information_schema.columns
+WHERE table_name='${queryName}' and column_name='id' and table_schema = '${schemaName}';
+          `,
           {
             transaction,
           },
@@ -110,7 +117,8 @@ AND    NOT attisdropped
         }
 
         await queryInterface.sequelize.query(
-          `alter table "${sequenceTable}" alter column id set default nextval('${maxSequenceName}')`,
+          `alter table "${schemaName}"."${sequenceTable}"
+            alter column id set default nextval('${maxSequenceName}')`,
           {
             transaction,
           },
@@ -121,7 +129,9 @@ AND    NOT attisdropped
     if (options.alter) {
       const columns = await queryInterface.describeTable(tableName, options);
 
-      for (const columnName in childAttributes) {
+      for (const attribute in childAttributes) {
+        const columnName = childAttributes[attribute].field;
+
         if (!columns[columnName]) {
           await queryInterface.addColumn(tableName, columnName, childAttributes[columnName], options);
         }
@@ -129,7 +139,7 @@ AND    NOT attisdropped
     }
   }
 
-  static async createTable(tableName, attributes, options, model, parentTables) {
+  static async createTable(tableName, attributes, options, model, parentTables, db) {
     let sql = '';
 
     options = { ...options };
@@ -154,7 +164,11 @@ AND    NOT attisdropped
 
     sql = `${queryGenerator.createTableQuery(tableName, attributes, options)}`.replace(
       ';',
-      ` INHERITS (${parentTables.map((t) => `"${t}"`).join(', ')});`,
+      ` INHERITS (${parentTables
+        .map((t) => {
+          return db.utils.quoteTable(db.utils.addSchema(t, db.options.schema));
+        })
+        .join(', ')});`,
     );
 
     return await model.sequelize.query(sql, options);

package/src/types.ts

@@ -16,6 +16,10 @@ export type ModelCreateWithAssociationsEventType = 'afterCreateWithAssociations'
 export type ModelUpdateWithAssociationsEventType = 'afterUpdateWithAssociations';
 export type ModelSaveWithAssociationsEventType = 'afterSaveWithAssociations';
 
+export type ModelBulkCreateEvnetType = 'beforeBulkCreate' | 'afterBulkCreate';
+export type ModelBulkUpdateEvnetType = 'beforeBulkUpdate' | 'afterBulkUpdate';
+export type ModelBulkDestroyEvnetType = 'beforeBulkDestroy' | 'afterBulkDestroy';
+
 export type ModelValidateEventTypes = ModelValidateEventType | `${CollectionNameType}.${ModelValidateEventType}`;
 export type ModelCreateEventTypes = ModelCreateEventType | `${CollectionNameType}.${ModelCreateEventType}`;
 export type ModelUpdateEventTypes = ModelUpdateEventType | `${CollectionNameType}.${ModelUpdateEventType}`;
@@ -25,6 +29,10 @@ export type ModelCreateWithAssociationsEventTypes = ModelCreateWithAssociationsE
 export type ModelUpdateWithAssociationsEventTypes = ModelUpdateWithAssociationsEventType | `${CollectionNameType}.${ModelUpdateWithAssociationsEventType}`;
 export type ModelSaveWithAssociationsEventTypes = ModelSaveWithAssociationsEventType | `${CollectionNameType}.${ModelSaveWithAssociationsEventType}`;
 
+export type ModelBulkCreateEvnetTypes = ModelBulkCreateEvnetType | `${CollectionNameType}.${ModelBulkCreateEvnetType}`;
+export type ModelBulkUpdateEvnetTypes = ModelBulkUpdateEvnetType | `${CollectionNameType}.${ModelBulkUpdateEvnetType}`;
+export type ModelBulkDestroyEvnetTypes = ModelBulkDestroyEvnetType | `${CollectionNameType}.${ModelBulkDestroyEvnetType}`;
+
 export type ModelEventTypes = ModelSyncEventType
   | ModelValidateEventTypes
   | ModelCreateEventTypes
@@ -33,7 +41,10 @@ export type ModelEventTypes = ModelSyncEventType
   | ModelDestroyEventTypes
   | ModelCreateWithAssociationsEventTypes
   | ModelUpdateWithAssociationsEventTypes
-  | ModelSaveWithAssociationsEventTypes;
+  | ModelSaveWithAssociationsEventTypes
+  | ModelBulkCreateEvnetTypes
+  | ModelBulkUpdateEvnetTypes
+  | ModelBulkDestroyEvnetTypes;
 
 export type DatabaseBeforeDefineCollectionEventType = 'beforeDefineCollection';
 export type DatabaseAfterDefineCollectionEventType = 'afterDefineCollection';

package/src/update-associations.ts

@@ -6,7 +6,7 @@ import {
   HasOne,
   Hookable,
   ModelStatic,
-  Transactionable,
+  Transactionable
 } from 'sequelize';
 import { Model } from './model';
 import { UpdateGuard } from './update-guard';
@@ -392,7 +392,7 @@ export async function updateMultipleAssociation(
     }
 
     if (isStringOrNumber(value)) {
-      await model[setAccessor](value, { transaction, context });
+      await model[setAccessor](value, { transaction, context, individualHooks: true });
       return;
     }
 
@@ -402,6 +402,7 @@ export async function updateMultipleAssociation(
 
     const list1 = []; // to be setted
     const list2 = []; // to be added
+    const created = [];
     for (const item of value) {
       if (isUndefinedOrNull(item)) {
         continue;
@@ -413,12 +414,17 @@ export async function updateMultipleAssociation(
       } else if (item.sequelize) {
         list1.push(item);
       } else if (typeof item === 'object') {
+        const targetKey = (association as any).targetKey || 'id';
+        if (item[targetKey]) {
+          created.push(item[targetKey]);
+          list1.push(item[targetKey]);
+        }
         list2.push(item);
       }
     }
 
     // associate targets in lists1
-    await model[setAccessor](list1, { transaction, context });
+    await model[setAccessor](list1, { transaction, context, individualHooks: true });
 
     const list3 = [];
     for (const item of list2) {
@@ -456,8 +462,9 @@ export async function updateMultipleAssociation(
           continue;
         }
         const addAccessor = association.accessors.add;
-
-        await model[addAccessor](item[pk], accessorOptions);
+        if (!created.includes(item[pk])) {
+          await model[addAccessor](item[pk], accessorOptions);
+        }
         if (!recursive) {
           continue;
         }

package/src/update-guard.ts

@@ -13,6 +13,7 @@ type UpdateAction = 'create' | 'update';
 export class UpdateGuard {
   model: ModelStatic<any>;
   action: UpdateAction;
+  underscored: boolean;
   private associationKeysToBeUpdate: AssociationKeysToBeUpdate;
   private blackList: BlackList;
   private whiteList: WhiteList;
@@ -162,6 +163,11 @@ export class UpdateGuard {
     guard.setBlackList(options.blacklist);
     guard.setAction(lodash.get(options, 'action', 'update'));
     guard.setAssociationKeysToBeUpdate(options.updateAssociationValues);
+
+    if (options.underscored) {
+      guard.underscored = options.underscored;
+    }
+
     return guard;
   }
 }