tachybase_todo/packages/plugins/@nocobase/plugin-collection-manager/src/server/models/collection.ts
jack zhang 705b7449f0
feat: new plugin manager, supports adding plugins through UI (#2430)
* refactor: plugin manager page

* fix: bug

* feat: addByNpm api

* fix: improve the addByNpm

* feat: improve applicationPlugins:list api

* fix: re-download npm package when restart app

* fix: plugin delete api

* feat: plugin detail api

* feat: zipUrl add api

* fix: upload api bug

* fix: plugin detail info

* feat: upgrade api

* fix: upload api

* feat: handle plugin load error

* feat: support authToken

* feat: muti lang

* fix: build error

* fix: self review

* Update plugin-manager.ts

* fix: bug

* fix: bug

* fix: bug

* fix: bug

* fix: bug

* fix: bugs

* fix: detail click and remove isOfficial

* fix: upgrade no refresh

* fix: file size and type check

* fix: bug

* fix: upgrade error

* fix: bug

* fix: bug

* fix: plugin card layout

* fix: handling exceptional cases

* fix: tgz file support

* fix: macos compress file

* fix: bug

* fix: bug

* fix: bug

* fix: bug

* fix: add upgrade npm type

* fix: bugs

* fix: bug

* fix: change plugins static expose url

* fix: api prefix

* fix: bug

* fix: add nginx `/static/plugin/` path

* fix: bugs and pr docker build no dts

* fix: bug

* fix: build tools bug

* fix: improve code

* fix: build bug

* feat: improve plugin info

* fix: ui bug

* fix: plugin document bug

* feat: improve code

* feat: improve code

* feat: process dev deps check

* feat: improve code

* feat: process.env.IS_DEV_CMD

* fix: do not delete the plugin package

* feat: plugin symlink

* fix: tsx watch --ignore=./storage/plugins/**

* fix: test error

* fix: improve code

* fix: improve code

* fix: emitStartedEvent

* fix: improve code

* fix: type error

* fix: test error

* test: console.log

* fix: createStoragePluginSymLink

* fix: clientStaticMiddleware rename to clientStaticUtils

* feat: build tools support plugins folder

* fix: 350px

* fix: error

* feat: client dev support plugin folder

* fix: clear cli options

* fix: typeError: Converting circular structure to JSON

* fix: plugin name

* chore: restart application after command

* feat: upgrade error & docs

* Update v14-changelog.md

* Update v14-changelog.md

* Update v14-changelog.md

* fix: gateway test

* refactor(plugin-workflow): add ready state for gracefully tearing down

* Revert "chore: restart application after command"

This reverts commit 5015274f8e4e06e506e15754b672330330e8c7f8.

* chore: stop application whe restart

* T 1218 change plugin folder (#2629)

* feat: change folder name

* feat: change `pm create` command

* feat:  revert plugin name change

* fix: delete samples

* feat: change plugins folder

* fix: pm create

* feat: update docs

* fix: link package error

* fix: docs

* fix: create command

* fix: pm add error

* fix: create  add build

* fix: pm creatre + add

* feat: add tar command

* fix: docs

* fix: bug

* fix: docs

---------

Co-authored-by: chenos <chenlinxh@gmail.com>

* feat: docs

* Update your-fisrt-plugin.md

* Update your-fisrt-plugin.md

* chore: application reload

* chore: test

* fix: pm add error

* chore: preset install skip exists plugin

* fix: createIfNotExists

---------

Co-authored-by: chenos <chenlinxh@gmail.com>
Co-authored-by: chareice <chareice@live.com>
Co-authored-by: Zhou <zhou.working@gmail.com>
Co-authored-by: mytharcher <mytharcher@gmail.com>
2023-09-12 22:39:23 +08:00

202 lines
4.9 KiB
TypeScript

import Database, { Collection, MagicAttributeModel, SyncOptions, Transactionable } from '@nocobase/database';
import lodash from 'lodash';
import { FieldModel } from './field';
interface LoadOptions extends Transactionable {
// TODO
skipField?: boolean | Array<string>;
skipExist?: boolean;
}
export class CollectionModel extends MagicAttributeModel {
get db(): Database {
return (<any>this.constructor).database;
}
async load(loadOptions: LoadOptions = {}) {
const { skipExist, skipField, transaction } = loadOptions;
const name = this.get('name');
let collection: Collection;
const collectionOptions = {
...this.get(),
fields: [],
};
if (this.db.hasCollection(name)) {
collection = this.db.getCollection(name);
if (skipExist) {
return collection;
}
collection.updateOptions(collectionOptions);
} else {
collection = this.db.collection(collectionOptions);
}
if (!skipField) {
await this.loadFields({ transaction });
}
if (lodash.isArray(skipField)) {
await this.loadFields({ transaction, skipField });
}
await this.db.emitAsync('collection:loaded', {
collection,
transaction,
});
return collection;
}
async loadFields(
options: Transactionable & {
skipField?: Array<string>;
includeFields?: Array<string>;
} = {},
) {
let fields = this.get('fields') || [];
if (!fields.length) {
fields = await this.getFields(options);
}
if (options.skipField) {
fields = fields.filter((field) => !options.skipField.includes(field.name));
}
if (options.includeFields) {
fields = fields.filter((field) => options.includeFields.includes(field.name));
}
// @ts-ignore
const instances: FieldModel[] = fields;
for (const instance of instances) {
await instance.load(options);
}
}
async remove(options?: any) {
const { transaction } = options || {};
const name = this.get('name');
const collection = this.db.getCollection(name);
if (!collection) {
return;
}
const fields = await this.db.getRepository('fields').find({
filter: {
'type.$in': ['belongsToMany', 'belongsTo', 'hasMany', 'hasOne'],
},
transaction,
});
for (const field of fields) {
if (field.get('target') && field.get('target') === name) {
await field.destroy({ transaction });
} else if (field.get('through') && field.get('through') === name) {
await field.destroy({ transaction });
}
}
await collection.removeFromDb({
transaction,
});
}
async migrate(options?: SyncOptions & Transactionable) {
const collection = await this.load({
transaction: options?.transaction,
});
// postgres support zero column table, other database should not sync it to database
// @ts-ignore
if (Object.keys(collection.model.tableAttributes).length == 0 && !this.db.inDialect('postgres')) {
return;
}
try {
await collection.sync({
force: false,
alter: {
drop: false,
},
...options,
});
} catch (error) {
console.error(error);
const name = this.get('name');
this.db.removeCollection(name);
throw error;
}
}
isInheritedModel() {
return this.get('inherits');
}
async findParents(options: Transactionable) {
const { transaction } = options;
const findModelParents = async (model: CollectionModel, carry = []) => {
if (!model.get('inherits')) {
return;
}
const parents = lodash.castArray(model.get('inherits'));
for (const parent of parents) {
const parentModel = (await this.db.getCollection('collections').repository.findOne({
filterByTk: parent,
transaction,
})) as CollectionModel;
carry.push(parentModel.get('name'));
await findModelParents(parentModel, carry);
}
return carry;
};
return findModelParents(this);
}
async parentFields(options: Transactionable) {
const { transaction } = options;
return this.db.getCollection('fields').repository.find({
filter: {
collectionName: { $in: await this.findParents({ transaction }) },
},
transaction,
});
}
// sync fields from parents
async syncParentFields(options: Transactionable) {
const { transaction } = options;
const ancestorFields = await this.parentFields({ transaction });
const selfFields = await this.getFields({ transaction });
const inheritedFields = ancestorFields.filter((field: FieldModel) => {
return (
!field.isAssociationField() &&
!selfFields.find((selfField: FieldModel) => selfField.get('name') == field.get('name'))
);
});
for (const inheritedField of inheritedFields) {
await this.createField(lodash.omit(inheritedField.toJSON(), ['key', 'collectionName', 'sort']), {
transaction,
});
}
}
}