tachybase_todo/packages/core/database/src/collection.ts
被雨水过滤的空气-Rain 573cde0a21
feat(variable): lazy load association fields (#2382)
* refactor: remove useless code

* feat: should always show user variable

* style: optimize style of variable input

* feat: change maxDepth of user varialbe to 3

* refactor: migrate getFieldDefaultValue to SchemaSettings.tsx

* feat: support to parse variables

* feat: support to parse array fields

* refactor: make testing more stable

* chore: fix CI

* feat: support to parse current user

* fix: fix tests

* feat: support to register variable

* feat: support to parse "$context"

* refactor: remove useless code

* fix: fix build

* fix: fix build

* test: make stable

* docs: add doc

* fix: fix T-1267

* fix: fix T-1268

* fix: fix T-1269

* fix: fix T-1271

* fix: fix T-1274

* refactor: improve code

* feat(variable): support local variable

* fix: fix T-1280

* refactor: close T-881

* refactor: remove useLazyLoadAssociation

* fix: fix T-1289,T-1290

* fix: fix T-1296

* refactor(AssignedField): replace user variable

* refactor: extract useBaseVariable

* refactor(AssignedField): replace variables

* feat(useVariables): support to use array as local variables

* refactor: improve variables (T-1295)

* feat: limit user choice (T-1297)

* fix: fix T-1305

* refactor: extract as SchemaSettings.DataScope

* refactor: improve linkage rules

* refactor: improve linkage rules of Action

* chore: fix build

* refactor: improve data scope of association fields

* chore: fix build

* feat: select limit

* refactor: use VariableInput to replace other

* fix: fix can not input

* fix(AssignedField): fix cannot close variables list

* test: fix errors

* refactor: migrate to new file

* fix: uniq

* fix: filter empty values

* fix: transform variables value

* fix: should sum numbers (T-1330)

* fix: fix Select (T-1337)

* refactor: use useMemo

* refactor: use hooks

* refactor: use hooks

* refactor: use hooks

* refactor: remove useless code

* refactor: rename `$form` to `$nForm` and `$record` to `$nRecord`

* fix: fix T-1334

* refactor(LinkageRuleActionGroup): use hooks

* refactor(FormButtonLinkageRuleAction): use hooks

* refactor: add type

* fix: avoid crashing

* refactor: rename `$date` to `$nDate`

* fix: fix T-1348

* perf: avoid duplicate requests

* test: fix error

* fix: fix T-1355

* fix: fix T-1355

* fix: fix T-1345

* fix: fix T-1346

* refactor(useVariableOptions): replace query with parameter

* fix: fix T-1335

* chore: fix build

* fix: fix T-1453

* refactor: remove useless code

* fix: fix T-1447

* fix: should update when seting default value

* fix: fix T-1454

* chore(eslint): ignore docker

* fix: fix T-1440

* refactor: use hooks

* fix: fix T-1332

* fix(defaultValue): should use Select mode

* fix(defaultValue): fix Checkbox

* refactor: rename and comment

* refactor: rename file name and hook name

* feat(subForm): support lazy load association fields

* fix: filter empty values

* fix(defaultValue): schema type of Checkbox should be void

* fix: fix T-1479

* fix: fix T-1491

* fix(ToOneNester): should use RecordProvider

* fix: fix T-1493

* chore: add comment

* fix: fix T-1495

* chore: fix build

* test: make pass

* fix: fix T-1503

* fix: fix T-1504

* fix: fix transformVariableValue

* fix: disable unsupport options

* refactor(useVariableOptions): add noDisabled params

* fix: data scope support to select to-many fields

* chore: add comment

* refactor: improve default value

* refactor: extract as useIsAllowToSetDefaultValue

* fix: should not support to set default value in edit mode

* fix: only the default values for sub-forms and sub-tables are valid

* fix: limit default value of association fields

* fix: fix '$nForm' variable

* fix: allow all inherit chain

* fix: optimize default value

* fix: optimize json field

* fix(currentObject): avoid error

* fix: should not show variable string

* fix: active fields

* fix: avoid errors

* feat: support special case

* fix: fix CI

* chore: fix build

* fix: json

* refactor: rename flag name

* fix: fix T-1559

* fix: fix T-1515

* fix: avoid crash

* fix: fix T-1520

* fix: fix T-1521

* fix: fix T-1523

* fix: fix T-1563

* fix: fix T-1565

* fix: fix T-1525

* fix: fix T-1524

* fix: fix T-1603

* fix: fix T-1332

* fix: fix T-1559

* fix: fix T-1602

* fix: fix T-1608

* fix: fix T-1612 T-1609

* fix: fix T-1681

* fix: fix T-1711

* fix: fix T-1713

* fix: fix T-1680

* chore: close T-1550

* fix: fix T-1507

* chore: avoid crashing

* fix: fix T-1557

* perf: close T-1726

* fix: fix T-1727

* fix: fix T-1741

* fix: fix T-1740

* chore(workflow): compact

* chore: should not to support to set default value in assign field values

* perf: compat and perf (T-1736)

* fix: fix T-1872

* fix: fix T-1877

* fix: fix quarter variables

* chore: add README

* chore: front-end should not depend on back-end code

* chore: should disable all variable options if no field is selected

* chore: should be a leaf if it has no children

* chore: fix build error

* fix: compat $form

* fix: compat $form

* chore: fix build

* chore: fix build

* fix: typeError: Cannot read properties of undefined (reading 'template')

* chore: fix test

* chore: add test

* fix: fix T-2072

* chore: optimize eslint

* perf: reduce number of requests

* fix: fix JSON

* test: fix error

* fix(e2e): avoid error

---------

Co-authored-by: chenos <chenlinxh@gmail.com>
2023-10-07 15:49:09 +08:00

727 lines
18 KiB
TypeScript

import merge from 'deepmerge';
import { EventEmitter } from 'events';
import { default as _, default as lodash } from 'lodash';
import {
ModelOptions,
ModelStatic,
QueryInterfaceDropTableOptions,
SyncOptions,
Transactionable,
Utils,
} from 'sequelize';
import { Database } from './database';
import { BelongsToField, Field, FieldOptions, HasManyField } from './fields';
import { Model } from './model';
import { AdjacencyListRepository } from './repositories/tree-repository/adjacency-list-repository';
import { Repository } from './repository';
import { checkIdentifier, md5, snakeCase } from './utils';
export type RepositoryType = typeof Repository;
export type CollectionSortable = string | boolean | { name?: string; scopeKey?: string };
type dumpable = 'required' | 'optional' | 'skip';
function EnsureAtomicity(target: any, propertyKey: string, descriptor: PropertyDescriptor) {
const originalMethod = descriptor.value;
descriptor.value = function (...args: any[]) {
const model = this.model;
const beforeAssociationKeys = Object.keys(model.associations);
const beforeRawAttributes = Object.keys(model.rawAttributes);
try {
return originalMethod.apply(this, args);
} catch (error) {
// remove associations created in this method
const afterAssociationKeys = Object.keys(model.associations);
const createdAssociationKeys = lodash.difference(afterAssociationKeys, beforeAssociationKeys);
for (const key of createdAssociationKeys) {
delete this.model.associations[key];
}
const afterRawAttributes = Object.keys(model.rawAttributes);
const createdRawAttributes = lodash.difference(afterRawAttributes, beforeRawAttributes);
console.log({
beforeRawAttributes,
afterRawAttributes,
});
for (const key of createdRawAttributes) {
delete this.model.rawAttributes[key];
}
throw error;
}
};
return descriptor;
}
export interface CollectionOptions extends Omit<ModelOptions, 'name' | 'hooks'> {
name: string;
title?: string;
namespace?: string;
/**
* Used for @nocobase/plugin-duplicator
* @see packages/core/database/src/collection-group-manager.tss
*
* @prop {'required' | 'optional' | 'skip'} dumpable - Determine whether the collection is dumped
* @prop {string[] | string} [with] - Collections dumped with this collection
* @prop {any} [delayRestore] - A function to execute after all collections are restored
*/
duplicator?:
| dumpable
| {
dumpable: dumpable;
with?: string[] | string;
delayRestore?: any;
};
tableName?: string;
inherits?: string[] | string;
viewName?: string;
writableView?: boolean;
filterTargetKey?: string;
fields?: FieldOptions[];
model?: string | ModelStatic<Model>;
repository?: string | RepositoryType;
sortable?: CollectionSortable;
/**
* @default true
*/
autoGenId?: boolean;
/**
* @default 'options'
*/
magicAttribute?: string;
tree?: string;
template?: string;
[key: string]: any;
}
export interface CollectionContext {
database: Database;
}
export class Collection<
TModelAttributes extends {} = any,
TCreationAttributes extends {} = TModelAttributes
> extends EventEmitter {
options: CollectionOptions;
context: CollectionContext;
isThrough?: boolean;
fields: Map<string, any> = new Map<string, any>();
model: ModelStatic<Model>;
repository: Repository<TModelAttributes, TCreationAttributes>;
constructor(options: CollectionOptions, context: CollectionContext) {
super();
this.context = context;
this.options = options;
this.checkOptions(options);
this.bindFieldEventListener();
this.modelInit();
this.db.modelCollection.set(this.model, this);
// set tableName to collection map
// the form of key is `${schema}.${tableName}` if schema exists
// otherwise is `${tableName}`
this.db.tableNameCollectionMap.set(this.getTableNameWithSchemaAsString(), this);
if (!options.inherits) {
this.setFields(options.fields);
}
this.setRepository(options.repository);
this.setSortable(options.sortable);
}
get filterTargetKey() {
const targetKey = lodash.get(this.options, 'filterTargetKey', this.model.primaryKeyAttribute);
if (!targetKey && this.model.rawAttributes['id']) {
return 'id';
}
return targetKey;
}
get name() {
return this.options.name;
}
get titleField() {
return (this.options.titleField as string) || this.model.primaryKeyAttribute;
}
get db() {
return this.context.database;
}
get treeParentField(): BelongsToField | null {
for (const [_, field] of this.fields) {
if (field.options.treeParent) {
return field;
}
}
}
get treeChildrenField(): HasManyField | null {
for (const [_, field] of this.fields) {
if (field.options.treeChildren) {
return field;
}
}
}
tableName() {
const { name, tableName } = this.options;
const tName = tableName || name;
return this.options.underscored ? snakeCase(tName) : tName;
}
/**
* TODO
*/
modelInit() {
if (this.model) {
return;
}
const { name, model, autoGenId = true } = this.options;
let M: ModelStatic<Model> = Model;
if (this.context.database.sequelize.isDefined(name)) {
const m = this.context.database.sequelize.model(name);
if ((m as any).isThrough) {
// @ts-ignore
this.model = m;
// @ts-ignore
this.model.database = this.context.database;
// @ts-ignore
this.model.collection = this;
return;
}
}
if (typeof model === 'string') {
M = this.context.database.models.get(model) || Model;
} else if (model) {
M = model;
}
// @ts-ignore
this.model = class extends M {};
this.model.init(null, this.sequelizeModelOptions());
if (!autoGenId) {
this.model.removeAttribute('id');
}
// @ts-ignore
this.model.database = this.context.database;
// @ts-ignore
this.model.collection = this;
}
setRepository(repository?: RepositoryType | string) {
let repo = Repository;
if (typeof repository === 'string') {
repo = this.context.database.repositories.get(repository) || Repository;
}
if (this.options.tree == 'adjacency-list' || this.options.tree == 'adjacencyList') {
repo = AdjacencyListRepository;
}
this.repository = new repo(this);
}
forEachField(callback: (field: Field) => void) {
return [...this.fields.values()].forEach(callback);
}
findField(callback: (field: Field) => boolean) {
return [...this.fields.values()].find(callback);
}
hasField(name: string) {
return this.fields.has(name);
}
getField<F extends Field>(name: string): F {
return this.fields.get(name);
}
addField(name: string, options: FieldOptions): Field {
return this.setField(name, options);
}
checkFieldType(name: string, options: FieldOptions) {
if (!this.options.underscored) {
return;
}
const fieldName = options.field || snakeCase(name);
const field = this.findField((f) => {
if (f.name === name) {
return false;
}
if (f.field) {
return f.field === fieldName;
}
return snakeCase(f.name) === fieldName;
});
if (!field) {
return;
}
if (options.type !== field.type) {
throw new Error(`fields with same column must be of the same type ${JSON.stringify(options)}`);
}
}
@EnsureAtomicity
setField(name: string, options: FieldOptions): Field {
checkIdentifier(name);
this.checkFieldType(name, options);
const { database } = this.context;
if (options.source) {
const [sourceCollectionName, sourceFieldName] = options.source.split('.');
const sourceCollection = this.db.collections.get(sourceCollectionName);
if (!sourceCollection) {
this.db.logger.warn(
`source collection "${sourceCollectionName}" not found for field "${name}" at collection "${this.name}"`,
);
}
const sourceField = sourceCollection.fields.get(sourceFieldName);
if (!sourceField) {
this.db.logger.warn(
`source field "${sourceFieldName}" not found for field "${name}" at collection "${this.name}"`,
);
} else {
options = { ...lodash.omit(sourceField.options, 'name'), ...options };
}
}
this.emit('field.beforeAdd', name, options, { collection: this });
const field = database.buildField(
{ name, ...options },
{
...this.context,
collection: this,
},
);
const oldField = this.fields.get(name);
if (oldField && oldField.options.inherit && field.typeToString() != oldField.typeToString()) {
throw new Error(
`Field type conflict: cannot set "${name}" on "${this.name}" to ${options.type}, parent "${name}" type is ${oldField.options.type}`,
);
}
if (this.options.autoGenId !== false && options.primaryKey) {
this.model.removeAttribute('id');
}
this.removeField(name);
this.fields.set(name, field);
this.emit('field.afterAdd', field);
// refresh children models
if (this.isParent()) {
for (const child of this.context.database.inheritanceMap.getChildren(this.name, {
deep: false,
})) {
const childCollection = this.db.getCollection(child);
const existField = childCollection.getField(name);
if (!existField || existField.options.inherit) {
childCollection.setField(name, {
...options,
inherit: true,
});
}
}
}
return field;
}
setFields(fields: FieldOptions[], resetFields = true) {
if (!Array.isArray(fields)) {
return;
}
if (resetFields) {
this.resetFields();
}
for (const { name, ...options } of fields) {
this.addField(name, options);
}
}
resetFields() {
const fieldNames = this.fields.keys();
for (const fieldName of fieldNames) {
this.removeField(fieldName);
}
}
remove() {
this.context.database.removeCollection(this.name);
}
async removeFromDb(options?: QueryInterfaceDropTableOptions) {
if (
!this.isView() &&
(await this.existsInDb({
transaction: options?.transaction,
}))
) {
const queryInterface = this.db.sequelize.getQueryInterface();
await queryInterface.dropTable(this.getTableNameWithSchema(), options);
}
this.remove();
}
async existsInDb(options?: Transactionable) {
return this.db.queryInterface.collectionTableExists(this, options);
}
removeField(name: string): void | Field {
if (!this.fields.has(name)) {
return;
}
const field = this.fields.get(name);
const bool = this.fields.delete(name);
if (bool) {
if (this.isParent()) {
for (const child of this.db.inheritanceMap.getChildren(this.name, {
deep: false,
})) {
const childCollection = this.db.getCollection(child);
const existField = childCollection.getField(name);
if (existField && existField.options.inherit) {
childCollection.removeField(name);
}
}
}
this.emit('field.afterRemove', field);
}
return field as Field;
}
/**
* TODO
*/
updateOptions(options: CollectionOptions, mergeOptions?: any) {
let newOptions = lodash.cloneDeep(options);
newOptions = merge(this.options, newOptions, mergeOptions);
this.context.database.emit('beforeUpdateCollection', this, newOptions);
this.options = newOptions;
this.setFields(options.fields, false);
if (options.repository) {
this.setRepository(options.repository);
}
this.context.database.emit('afterUpdateCollection', this);
return this;
}
setSortable(sortable) {
if (!sortable) {
return;
}
if (sortable === true) {
this.setField('sort', {
type: 'sort',
hidden: true,
});
}
if (typeof sortable === 'string') {
this.setField(sortable, {
type: 'sort',
hidden: true,
});
} else if (typeof sortable === 'object') {
const { name, ...opts } = sortable;
this.setField(name || 'sort', { type: 'sort', hidden: true, ...opts });
}
}
/**
* TODO
*
* @param name
* @param options
*/
updateField(name: string, options: FieldOptions) {
if (!this.hasField(name)) {
throw new Error(`field ${name} not exists`);
}
if (options.name && options.name !== name) {
this.removeField(name);
}
this.setField(options.name || name, options);
}
addIndex(index: string | string[] | { fields: string[]; unique?: boolean; [key: string]: any }) {
if (!index) {
return;
}
// collection defined indexes
const indexes: any = this.model.options.indexes || [];
let indexName = [];
let indexItem;
if (typeof index === 'string') {
indexItem = {
fields: [index],
};
indexName = [index];
} else if (Array.isArray(index)) {
indexItem = {
fields: index,
};
indexName = index;
} else if (index?.fields) {
indexItem = index;
indexName = index.fields;
}
if (lodash.isEqual(this.model.primaryKeyAttributes, indexName)) {
return;
}
const name: string = this.model.primaryKeyAttributes.join(',');
if (name.startsWith(`${indexName.join(',')},`)) {
return;
}
for (const item of indexes) {
if (lodash.isEqual(item.fields, indexName)) {
return;
}
const name: string = item.fields.join(',');
if (name.startsWith(`${indexName.join(',')},`)) {
return;
}
}
if (!indexItem) {
return;
}
indexes.push(indexItem);
const tableName = this.model.getTableName();
// @ts-ignore
this.model._indexes = this.model.options.indexes
// @ts-ignore
.map((index) => Utils.nameIndex(this.model._conformIndex(index), tableName))
.map((item) => {
if (item.name && item.name.length > 63) {
item.name = 'i_' + md5(item.name);
}
return item;
});
this.refreshIndexes();
}
removeIndex(fields: any) {
if (!fields) {
return;
}
// @ts-ignore
const indexes: any[] = this.model._indexes;
// @ts-ignore
this.model._indexes = indexes.filter((item) => {
return !lodash.isEqual(item.fields, fields);
});
this.refreshIndexes();
}
refreshIndexes() {
// @ts-ignore
const indexes: any[] = this.model._indexes;
// @ts-ignore
this.model._indexes = lodash.uniqBy(
indexes
.filter((item) => {
return item.fields.every((field) =>
Object.values(this.model.rawAttributes).find((fieldVal) => fieldVal.field === field),
);
})
.map((item) => {
if (this.options.underscored) {
item.fields = item.fields.map((field) => snakeCase(field));
}
return item;
}),
'name',
);
}
async sync(syncOptions?: SyncOptions) {
const modelNames = new Set([this.model.name]);
const { associations } = this.model;
for (const associationKey in associations) {
const association = associations[associationKey];
modelNames.add(association.target.name);
if ((<any>association).through) {
modelNames.add((<any>association).through.model.name);
}
}
const models: ModelStatic<Model>[] = [];
// @ts-ignore
this.context.database.sequelize.modelManager.forEachModel((model) => {
if (modelNames.has(model.name)) {
models.push(model);
}
});
for (const model of models) {
await model.sync(syncOptions);
}
}
public isInherited() {
return false;
}
public isParent() {
return this.context.database.inheritanceMap.isParentNode(this.name);
}
public getTableNameWithSchema() {
const tableName = this.model.tableName;
if (this.collectionSchema() && this.db.inDialect('postgres')) {
return this.db.utils.addSchema(tableName, this.collectionSchema());
}
return tableName;
}
public tableNameAsString(options?: { ignorePublicSchema: boolean }) {
const tableNameWithSchema = this.getTableNameWithSchema();
if (lodash.isString(tableNameWithSchema)) {
return tableNameWithSchema;
}
const schema = tableNameWithSchema.schema;
const tableName = tableNameWithSchema.tableName;
if (options?.ignorePublicSchema && schema === 'public') {
return tableName;
}
return `${schema}.${tableName}`;
}
public getTableNameWithSchemaAsString() {
const tableName = this.model.tableName;
if (this.collectionSchema() && this.db.inDialect('postgres')) {
return `${this.collectionSchema()}.${tableName}`;
}
return tableName;
}
public quotedTableName() {
return this.db.utils.quoteTable(this.getTableNameWithSchema());
}
public collectionSchema() {
if (this.options.schema) {
return this.options.schema;
}
if (this.db.options.schema) {
return this.db.options.schema;
}
if (this.db.inDialect('postgres')) {
return 'public';
}
return undefined;
}
public isView() {
return false;
}
protected sequelizeModelOptions() {
const { name } = this.options;
return {
..._.omit(this.options, ['name', 'fields', 'model', 'targetKey']),
modelName: name,
sequelize: this.context.database.sequelize,
tableName: this.tableName(),
};
}
private checkOptions(options: CollectionOptions) {
checkIdentifier(options.name);
this.checkTableName();
}
private checkTableName() {
const tableName = this.tableName();
for (const [k, collection] of this.db.collections) {
if (
collection.name != this.options.name &&
tableName === collection.tableName() &&
collection.collectionSchema() === this.collectionSchema()
) {
throw new Error(`collection ${collection.name} and ${this.name} have same tableName "${tableName}"`);
}
}
}
private bindFieldEventListener() {
this.on('field.afterAdd', (field: Field) => {
field.bind();
});
this.on('field.afterRemove', (field: Field) => {
field.unbind();
this.db.emit('field.afterRemove', field);
});
}
}