11 KiB
Field
Overview
Data table field management class (abstract class). It is also the base class for all field types, and any other field types are implemented by inheriting from this class.
Refer to Extended Field Types to see how to customize fields.
Constructor
It is usually not called directly by the developer, but mainly through the db.collection({ fields: [] }) method as a proxy entry.
Extended field is implemented mainly by inheriting the Field abstract class and registering it to a Database instance.
Signature
constructor(options: FieldOptions, context: FieldContext)
Parameter
| Name | Type | Default | Description |
|---|---|---|---|
options |
FieldOptions |
- | Field configuration object |
options.name |
string |
- | Field name |
options.type |
string |
- | Field type, corresponding to the name of the field type registered in the db |
context |
FieldContext |
- | Field context object |
context.database |
Database |
- | Database instance |
context.collection |
Collection |
- | Data table instance |
Instance Member
name
Field name.
type
Field type.
dataType
Data type of the field.
options
Configuration parameters to initialize the field.
context
Field context object.
Configuration Method
on()
Quick definition method based on data table events. It is equivalent to db.on(this.collection.name + '.' + eventName, listener).
It is usually not necessary to override this method when inheriting.
Signature
on(eventName: string, listener: (...args: any[]) => void)
Parameter
| Name | Type | Default | Description |
|---|---|---|---|
eventName |
string |
- | Event name |
listener |
(...args: any[]) => void |
- | Event listener |
off()
Quick removal method based on data table events. It is equivalent to db.off(this.collection.name + '.' + eventName, listener).
It is usually not necessary to override this method when inheriting.
Signature
off(eventName: string, listener: (...args: any[]) => void)
Parameter
| Name | Type | Default | Description |
|---|---|---|---|
eventName |
string |
- | Event name |
listener |
(...args: any[]) => void |
- | Event listener |
bind()
The execution content that is triggered when a field is added to data table. Typically used to add data table event listeners and other processing.
The corresponding super.bind() method needs to be called first when inheriting.
Signature
bind()
unbind()
The execution content that is triggered when a field is removed from data table. Typically used to remove data table event listeners and other processing.
The corresponding super.unbind() method needs to be called first when inheriting.
Signature
unbind()
get()
Get the values of a configuration item of the field.
Signature
get(key: string): any
Parameter
| Name | Type | Default | Description |
|---|---|---|---|
key |
string |
- | Name of the configuration item |
Example
const field = db.collection('users').getField('name');
// Get and return the values of the configuration item 'name'
console.log(field.get('name'));
merge()
Merge the values of a configuration item of the field.
Signature
merge(options: { [key: string]: any }): void
Parameter
| Name | Type | Default | Description |
|---|---|---|---|
options |
{ [key: string]: any } |
- | The configuration item to merge |
Example
const field = db.collection('users').getField('name');
field.merge({
// Add an index configuration
index: true
});
remove()
Remove a field from data table (from memory only).
Example
const books = db.getCollections('books');
books.getField('isbn').remove();
// really remove from db
await books.sync();
Database Method
removeFromDb()
Remove a field from the database.
Signature
removeFromDb(options?: Transactionable): Promise<void>
Parameter
| Name | Type | Default | Description |
|---|---|---|---|
options.transaction? |
Transaction |
- | Transaction instance |
existsInDb()
Check if a field exists in the database.
Signature
existsInDb(options?: Transactionable): Promise<boolean>
Parameter
| Name | Type | Default | Description |
|---|---|---|---|
options.transaction? |
Transaction |
- | Transaction instance |
Built-in Field Types
NodeBase has some built-in common field types, the corresponding type name can be used directly to specify the type of field upon definition. Fields of different types are configured differently, please refer to the list below.
The configuration items of all field types are passed through to Sequelize in addition to those described below. Therefore, all field configuration items supported by Sequelize can be used here (e.g. allowNull, defaultValue, etc.).
Moreover, server-side field types are mainly used for solving the problems of database storage and some algorithms, they are barely relevant to the field display types and the use of components in front-end. The front-end field types can be found in the corresponding tutorials.
'boolean'
Boolean type.
Example
db.collection({
name: 'books',
fields: [
{
type: 'boolean',
name: 'published'
}
]
});
'integer'
Integer type (32 bits).
Example
db.collection({
name: 'books',
fields: [
{
type: 'integer',
name: 'pages'
}
]
});
'bigInt'
Long integer type (64 bits).
Example
db.collection({
name: 'books',
fields: [
{
type: 'bigInt',
name: 'words'
}
]
});
'double'
Double-precision floating-point format (64 bits).
Example
db.collection({
name: 'books',
fields: [
{
type: 'double',
name: 'price'
}
]
});
'real'
Real type (PG only).
'decimal'
Decimal type.
'string'
String type. Equivalent to the VARCHAR type for most databases.
Example
db.collection({
name: 'books',
fields: [
{
type: 'string',
name: 'title'
}
]
});
'text'
Text type. Equivalent to the TEXT type for most databases.
Example
db.collection({
name: 'books',
fields: [
{
type: 'text',
name: 'content'
}
]
});
'password'
Password type (NodeBase extension). Password encryption based on the scrypt method of Node.js native crypto packages.
Example
db.collection({
name: 'users',
fields: [
{
type: 'password',
name: 'password',
length: 64, // Length, default is 64
randomBytesSize: 8 // Length of random bytes, default is 8
}
]
});
Parameter
| Name | Type | Default | Description |
|---|---|---|---|
length |
number |
64 | Length of characters |
randomBytesSize |
number |
8 | Length of random bytes |
'date'
Date type.
'time'
Time type.
'array'
Array type (PG only).
'json'
JSON type.
'jsonb'
JSONB type. (PG only, others will be compatible with the 'json' type).
'uuid'
UUID type.
'uid'
UID type (NodeBase extension). Short random string identifier type.
'formula'
Formula type (NodeBase extension). Mathematical formula calculation can be configured based on mathjs, and the formula can refer to the values of other columns in the same record to participate in the calculation.
Example
db.collection({
name: 'orders',
fields: [
{
type: 'double',
name: 'price'
},
{
type: 'integer',
name: 'quantity'
},
{
type: 'formula',
name: 'total',
expression: 'price * quantity'
}
]
});
'radio'
Radio type (NodeBase extension). The field value is 'true' for at most one row of data for the full table, all others are 'false' or 'null'.
Example
There is only one user marked as root in the entire system, once the root value of any other user is changed to true, all other records with root of true will be changed to false:
db.collection({
name: 'users',
fields: [
{
type: 'radio',
name: 'root',
}
]
});
'sort'
Sorting type (NodeBase extension). Sorting based on integer numbers, automatically generating new serial numbers for new records, and rearranging serial numbers when moving data.
If data table has the sortable option defined, the corresponding fields will be generated automatically.
Example
Posts are sortable based on the users they belong to.
db.collection({
name: 'posts',
fields: [
{
type: 'belongsTo',
name: 'user',
},
{
type: 'sort',
name: 'priority',
scopeKey: 'userId' // Sort data grouped by the values of userId
}
]
});
'virtual'
Virtual type. No Data is actually stored, it is used only when special getter/setter is defined.
'belongsTo'
Many-to-one association type. Foreign key is stored in its own table, as opposed to 'hasOne'/'hasMany'.
Example
Any post belongs to an author:
db.collection({
name: 'posts',
fields: [
{
type: 'belongsTo',
name: 'author',
target: 'users', // Default table name is the plural form of <name>
foreignKey: 'authorId', // Default is '<name> + Id'
sourceKey: 'id' // Default is id of the <target> table
}
]
});
'hasOne'
One-to-one association type. Foreign key is stored in the association table, as opposed to 'belongsTo'.
Example
Any user has a profile:
db.collection({
name: 'users',
fields: [
{
type: 'hasOne',
name: 'profile',
target: 'profiles', // Can be omitted
}
]
})
'hasMany'
One-to-many association type. The foreign key is stored in the association table, as opposed to 'belongsTo'.
Example
Any user can have multiple posts:
db.collection({
name: 'users',
fields: [
{
type: 'hasMany',
name: 'posts',
foreignKey: 'authorId',
sourceKey: 'id'
}
]
});
'belongsToMany'
Many-to-many association type. Intermediate table is used to store both foreign keys. If no existing table is specified as intermediate table, it will be created automatically.
Example
Any post can have multiple tags added to it, and any tag can be added to multiple posts:
db.collection({
name: 'posts',
fields: [
{
type: 'belongsToMany',
name: 'tags',
target: 'tags', // Can be omitted if name is the same
through: 'postsTags', // Intermediate table will be generated automatically if not specified
foreignKey: 'postId', // Foreign key in the intermediate table referring to the table itself
sourceKey: 'id', // Primary key of the table itself
otherKey: 'tagId' // Foreign key in the intermediate table referring to the association table
}
]
});
db.collection({
name: 'tags',
fields: [
{
type: 'belongsToMany',
name: 'posts',
through: 'postsTags', // Refer to the same intermediate table in the same set of relation
}
]
});