ruiling/tachybase_todo
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

refactor: change the field type names to uppercase

Browse Source
This commit is contained in:
chenos 2020-12-10 14:47:13 +08:00
parent e86b573296
commit 437c49d211
12 changed files with 181 additions and 107 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

19
packages/actions/src/actions/associate.ts
View File

@ -1,8 +1,13 @@
import { Context, Next } from '.';
import { list, get, create, update, destroy } from './common';
import { HasOne, BelongsTo, BelongsToMany, HasMany, Model, Relation } from '@nocobase/database';
import { Op } from 'sequelize';
import {
Model,
Relation,
HASONE,
BELONGSTO,
BELONGSTOMANY,
HASMANY,
} from '@nocobase/database';
/**
* 建立关联
@ -116,9 +121,9 @@ export async function remove(ctx: Context, next: Next) {
const options = TargetModel.parseApiJson({
fields,
});
if (resourceField instanceof HasOne || resourceField instanceof BelongsTo) {
if (resourceField instanceof HASONE || resourceField instanceof BELONGSTO) {
ctx.body = await associated[setAccessor](null);
} else if (resourceField instanceof HasMany || resourceField instanceof BelongsToMany) {
} else if (resourceField instanceof HASMANY || resourceField instanceof BELONGSTOMANY) {
const [model]: Model[] = await associated[getAccessor]({
...options,
where: {
@ -153,7 +158,7 @@ export async function toggle(ctx: Context, next: Next) {
const options = TargetModel.parseApiJson({
fields,
});
if (resourceField instanceof HasOne || resourceField instanceof BelongsTo) {
if (resourceField instanceof HASONE || resourceField instanceof BELONGSTO) {
const m1 = await associated[getAccessor]();
if (m1 && m1[resourceKeyAttribute || resourceField.options.targetKey || TargetModel.primaryKeyAttribute] == resourceKey) {
ctx.body = await associated[setAccessor](null);
@ -168,7 +173,7 @@ export async function toggle(ctx: Context, next: Next) {
});
ctx.body = await associated[setAccessor](m2);
}
} else if (resourceField instanceof HasMany || resourceField instanceof BelongsToMany) {
} else if (resourceField instanceof HASMANY || resourceField instanceof BELONGSTOMANY) {
const [model]: Model[] = await associated[getAccessor]({
...options,
where: {

28
packages/actions/src/actions/common.ts
View File

@ -1,5 +1,11 @@
import { Context, Next } from '.';
import { Relation, Model, HasOne, HasMany, BelongsTo, BelongsToMany } from '@nocobase/database';
import {
Model,
HASONE,
HASMANY,
BELONGSTO,
BELONGSTOMANY,
} from '@nocobase/database';
import { DEFAULT_PAGE, DEFAULT_PER_PAGE } from '@nocobase/resourcer';
import { Utils, Op } from 'sequelize';
import _ from 'lodash';
@ -159,10 +165,10 @@ export async function get(ctx: Context, next: Next) {
const options = TargetModel.parseApiJson({
fields,
});
if (resourceField instanceof HasOne || resourceField instanceof BelongsTo) {
if (resourceField instanceof HASONE || resourceField instanceof BELONGSTO) {
const model: Model = await associated[getAccessor]({ ...options, context: ctx });
ctx.body = model;
} else if (resourceField instanceof HasMany || resourceField instanceof BelongsToMany) {
} else if (resourceField instanceof HASMANY || resourceField instanceof BELONGSTOMANY) {
const [model]: Model[] = await associated[getAccessor]({
...options,
where: {
@ -219,7 +225,7 @@ export async function update(ctx: Context, next: Next) {
throw new Error(`${associatedName} associated model invalid`);
}
const { get: getAccessor } = resourceField.getAccessors();
if (resourceField instanceof HasOne || resourceField instanceof BelongsTo) {
if (resourceField instanceof HASONE || resourceField instanceof BELONGSTO) {
let model: Model = await associated[getAccessor]({ transaction, context: ctx });
if (model) {
// @ts-ignore
@ -227,7 +233,7 @@ export async function update(ctx: Context, next: Next) {
await model.updateAssociations(values, { transaction, context: ctx });
ctx.body = model;
}
} else if (resourceField instanceof HasMany || resourceField instanceof BelongsToMany) {
} else if (resourceField instanceof HASMANY || resourceField instanceof BELONGSTOMANY) {
const TargetModel = ctx.db.getModel(resourceField.getTarget());
const [model]: Model[] = await associated[getAccessor]({
where: {
@ -237,7 +243,7 @@ export async function update(ctx: Context, next: Next) {
context: ctx,
});
if (resourceField instanceof BelongsToMany) {
if (resourceField instanceof BELONGSTOMANY) {
const throughName = resourceField.getThroughName();
if (typeof values[throughName] === 'object') {
const ThroughModel = resourceField.getThroughModel();
@ -315,12 +321,12 @@ export async function destroy(ctx: Context, next: Next) {
const {get: getAccessor, remove: removeAccessor, set: setAccessor} = resourceField.getAccessors();
const TargetModel = ctx.db.getModel(resourceField.getTarget());
const { where } = TargetModel.parseApiJson({ filter, context: ctx });
if (resourceField instanceof HasOne || resourceField instanceof BelongsTo) {
if (resourceField instanceof HASONE || resourceField instanceof BELONGSTO) {
const model: Model = await associated[getAccessor](commonOptions);
await associated[setAccessor](null, commonOptions);
// @ts-ignore
ctx.body = await model.destroy(commonOptions);
} else if (resourceField instanceof HasMany || resourceField instanceof BelongsToMany) {
} else if (resourceField instanceof HASMANY || resourceField instanceof BELONGSTOMANY) {
const primaryKey = resourceKeyAttribute || resourceField.options.targetKey || TargetModel.primaryKeyAttribute;
const models: Model[] = await associated[getAccessor]({
where: resourceKey ? { [primaryKey]: resourceKey } : where,
@ -371,11 +377,11 @@ export async function sort(ctx: Context, next: Next) {
} = ctx.action.params;
if (associated && resourceField) {
if (resourceField instanceof HasOne || resourceField instanceof BelongsTo) {
if (resourceField instanceof HASONE || resourceField instanceof BELONGSTO) {
throw new Error(`the association (${resourceName} belongs to ${associatedName}) cannot be sorted`);
}
// TODO(feature)
if (resourceField instanceof BelongsToMany) {
if (resourceField instanceof BELONGSTOMANY) {
throw new Error('sorting for belongs to many association has not been implemented');
}
}
@ -406,7 +412,7 @@ export async function sort(ctx: Context, next: Next) {
const transaction = await ctx.db.sequelize.transaction();
const { where = {} } = Model.parseApiJson({ filter });
if (associated && resourceField instanceof HasMany) {
if (associated && resourceField instanceof HASMANY) {
where[resourceField.options.foreignKey] = associatedKey;
}

12
packages/actions/src/middlewares/associated.ts
View File

@ -1,6 +1,6 @@
import { Context, Next, associate } from '../actions';
import { Context, Next } from '../actions';
import { Action } from '@nocobase/resourcer';
import { HasOne, HasMany, BelongsTo, BelongsToMany, Model } from '@nocobase/database';
import { HASONE, HASMANY, BELONGSTO, BELONGSTOMANY } from '@nocobase/database';
export async function associated(ctx: Context, next: Next) {
if (!(ctx.action instanceof Action)) {
@ -23,12 +23,12 @@ export async function associated(ctx: Context, next: Next) {
let key: string;
switch (true) {
case field instanceof BelongsTo:
case field instanceof BELONGSTO:
key = field.options.targetKey || Model.primaryKeyAttribute;
break;
case field instanceof HasOne:
case field instanceof HasMany:
case field instanceof BelongsToMany:
case field instanceof HASONE:
case field instanceof HASMANY:
case field instanceof BELONGSTOMANY:
key = field.options.sourceKey;
break;
}

6
packages/database/src/__tests__/associations.test.ts
View File

@ -1,6 +1,10 @@
import { getDatabase } from './';
import {
HasMany, HasOne, Integer, BelongsTo, BelongsToMany
HASMANY as HasMany,
HASONE as HasOne,
INTEGER as Integer,
BELONGSTO as BelongsTo,
BELONGSTOMANY as BelongsToMany,
} from '../fields';
import { DataTypes } from 'sequelize';
import Database from '..';

58
packages/database/src/__tests__/hooks.test.ts
View File

@ -2,9 +2,9 @@ import { getDatabase } from './';
import Database from '../database';
import Table from '../table';
import Model from '../model';
import { FieldContext, Integer, registerField } from '../fields';
import { FieldContext, INTEGER, registerField } from '../fields';
class TestHookField extends Integer {
class TestHookField extends INTEGER {
constructor(options: any, context: FieldContext) {
super(options, context);
const Model = context.sourceTable.getModel();
@ -157,4 +157,58 @@ describe('hooks', () => {
const test = await Test3.create({});
expect(test.get('arr')).toEqual([ 1, 3, 2, 4 ]);
});
it.only('add hook in custom field', async () => {
const table = db.table({
name: 'test3',
fields: [
{
type: 'json',
name: 'arr',
defaultValue: [],
},
],
hooks: {
beforeCreate(model) {
model.set('name', 'beforeCreate1');
const arr = model.get('arr') as any[];
arr.push(3);
model.set('arr', arr);
console.log('beforeCreate in table');
},
afterCreate(model) {
model.set('name', 'afterCreate1');
const arr = model.get('arr') as any[];
arr.push(4);
model.set('arr', arr);
console.log('afterCreate in table');
},
},
});
table.addField({
type: 'string',
name: 'title',
});
// await table.sync();
let Test3 = db.getModel('test3');
Test3.beforeCreate((model) => {
const arr = model.get('arr') as any[];
arr.push(5);
model.set('arr', arr);
});
Test3.afterCreate((model) => {
const arr = model.get('arr') as any[];
arr.push(6);
model.set('arr', arr);
});
// 通过 table 新增
table.addField({
type: 'testHook',
name: 'testHook',
});
await table.sync();
Test3 = db.getModel('test3');
const test = await Test3.create({});
expect(test.get('arr')).toEqual([ 3, 5, 1, 4, 6, 2 ]);
});
});

38
packages/database/src/__tests__/types.test.ts
View File

@ -1,25 +1,25 @@
import {
buildField,
Boolean,
Integer,
String,
Text,
HasOne,
HasMany,
BelongsTo,
BelongsToMany,
Float,
Double,
Real,
Decimal,
Column,
Time,
Date,
DateOnly,
Array,
Json,
Jsonb,
Password
BOOLEAN as Boolean,
INTEGER as Integer,
STRING as String,
TEXT as Text,
HASONE as HasOne,
HASMANY as HasMany,
BELONGSTO as BelongsTo,
BELONGSTOMANY as BelongsToMany,
FLOAT as Float,
DOUBLE as Double,
REAL as Real,
DECIMAL as Decimal,
TIME as Time,
DATE as Date,
DATEONLY as DateOnly,
ARRAY as Array,
JSON as Json,
JSONB as Jsonb,
PASSWORD as Password,
} from '../fields';
import { DataTypes } from 'sequelize';
import { ABSTRACT } from 'sequelize/lib/data-types';

58
packages/database/src/fields/field-types.ts
View File

@ -81,13 +81,13 @@ export class Column extends Field {
}
}
export class Boolean extends Column {
export class BOOLEAN extends Column {
}
export class Number extends Column {
export class NUMBER extends Column {
}
export class Integer extends Number {
export class INTEGER extends NUMBER {
public readonly options: Options.IntegerOptions;
@ -117,7 +117,7 @@ export class Integer extends Number {
}
}
export class Float extends Number {
export class FLOAT extends NUMBER {
public readonly options: Options.FloatOptions;
@ -130,7 +130,7 @@ export class Float extends Number {
}
}
export class Double extends Number {
export class DOUBLE extends NUMBER {
public readonly options: Options.DoubleOptions;
public getAttributeOptions() {
@ -142,7 +142,7 @@ export class Double extends Number {
}
}
export class Decimal extends Number {
export class DECIMAL extends NUMBER {
public readonly options: Options.DecimalOptions;
@ -155,7 +155,7 @@ export class Decimal extends Number {
}
}
export class Real extends Number {
export class REAL extends NUMBER {
public readonly options: Options.RealOptions;
@ -168,7 +168,7 @@ export class Real extends Number {
}
}
export class String extends Column {
export class STRING extends Column {
public readonly options: Options.StringOptions;
@ -182,7 +182,7 @@ export class String extends Column {
}
}
export class Text extends Column {
export class TEXT extends Column {
public readonly options: Options.TextOptions;
@ -206,10 +206,10 @@ export class Text extends Column {
}
}
export class Time extends Column {
export class TIME extends Column {
}
export class Date extends Column {
export class DATE extends Column {
public readonly options: Options.DateOptions;
@ -223,13 +223,13 @@ export class Date extends Column {
}
}
export class DateOnly extends Column {
export class DATEONLY extends Column {
}
export class Virtual extends Column {
export class VIRTUAL extends Column {
}
export class Reference extends Virtual {
export class REFERENCE extends VIRTUAL {
public getDataType() {
return DataTypes.VIRTUAL;
@ -248,7 +248,7 @@ export class Reference extends Virtual {
}
}
export class Formula extends Virtual {
export class FORMULA extends VIRTUAL {
public getDataType() {
return DataTypes.VIRTUAL;
@ -284,7 +284,7 @@ export class Formula extends Virtual {
}
}
export class Password extends String {
export class PASSWORD extends STRING {
public getDataType() {
return DataTypes.STRING;
@ -307,7 +307,7 @@ export class Password extends String {
}
}
export class Array extends Column {
export class ARRAY extends Column {
public readonly options: Options.ArrayOptions;
@ -324,10 +324,10 @@ export class Array extends Column {
}
}
export class Json extends Column {
export class JSON extends Column {
}
export class Jsonb extends Column {
export class JSONB extends Column {
}
export interface HasOneAccessors {
@ -371,16 +371,16 @@ export interface BelongsToManyAccessors {
export abstract class Relation extends Field {
public getAssociationType() {
if (this instanceof HasOne) {
if (this instanceof HASONE) {
return 'hasOne';
}
if (this instanceof HasMany) {
if (this instanceof HASMANY) {
return 'hasMany';
}
if (this instanceof BelongsTo) {
if (this instanceof BELONGSTO) {
return 'belongsTo';
}
if (this instanceof BelongsToMany) {
if (this instanceof BELONGSTOMANY) {
return 'belongsToMany';
}
}
@ -390,10 +390,10 @@ export abstract class Relation extends Field {
if (target) {
return target;
}
if (this instanceof HasMany) {
if (this instanceof HASMANY) {
return name;
}
if (this instanceof BelongsToMany) {
if (this instanceof BELONGSTOMANY) {
return name;
}
return Utils.pluralize(name);
@ -462,7 +462,7 @@ class HasOneOrMany extends Relation {
}
}
export class HasOne extends HasOneOrMany {
export class HASONE extends HasOneOrMany {
public readonly options: Options.HasOneOptions;
@ -489,7 +489,7 @@ export class HasOne extends HasOneOrMany {
}
}
export class HasMany extends HasOneOrMany {
export class HASMANY extends HasOneOrMany {
public readonly options: Options.HasManyOptions;
@ -512,7 +512,7 @@ export class HasMany extends HasOneOrMany {
}
}
export class BelongsTo extends Relation {
export class BELONGSTO extends Relation {
public readonly options: Options.BelongsToOptions;
@ -567,7 +567,7 @@ export class BelongsTo extends Relation {
}
}
export class BelongsToMany extends Relation {
export class BELONGSTOMANY extends Relation {
public readonly options: Options.BelongsToManyOptions;

21
packages/database/src/fields/index.ts
View File

@ -110,15 +110,14 @@ export function buildField(options: FieldOptions, context: Fields.FieldContext)
registerFields({
...Fields,
// aliases
Int: Fields.Integer,
TinyInt: Fields.Integer,
TinyInteger: Fields.Integer,
SmallInt: Fields.Integer,
SmallInteger: Fields.Integer,
MediumInt: Fields.Integer,
MediumInteger: Fields.Integer,
BigInt: Fields.Integer,
BigInteger: Fields.Integer,
Timestamp: Fields.Date,
Creator: Fields.BelongsTo,
INT: Fields.INTEGER,
TINYINT: Fields.INTEGER,
TINYINTEGER: Fields.INTEGER,
SMALLINT: Fields.INTEGER,
SMALLINTEGER: Fields.INTEGER,
MEDIUMINT: Fields.INTEGER,
MEDIUMINTEGER: Fields.INTEGER,
BIGINT: Fields.INTEGER,
BIGINTEGER: Fields.INTEGER,
TIMESTAMP: Fields.DATE,
});

24
packages/database/src/model.ts
View File

@ -2,7 +2,13 @@ import {
Model as SequelizeModel, Op, Sequelize, ProjectionAlias, Utils, SaveOptions,
} from 'sequelize';
import Database from './database';
import { HasOne, HasMany, BelongsTo, BelongsToMany, getDataTypeKey } from './fields';
import {
getDataTypeKey,
HASONE,
HASMANY,
BELONGSTO,
BELONGSTOMANY,
} from './fields';
import { toInclude } from './utils';
export interface ApiJsonOptions {
@ -269,7 +275,7 @@ export abstract class Model extends SequelizeModel {
await this[accessors.set](data, opts);
} else if (typeof data === 'object') {
const Target = association.getTargetModel();
const targetAttribute = association instanceof BelongsTo
const targetAttribute = association instanceof BELONGSTO
? association.options.targetKey
: association.options.sourceKey;
if (data[targetAttribute]) {
@ -407,7 +413,7 @@ export abstract class Model extends SequelizeModel {
}
}
if (association instanceof BelongsToMany) {
if (association instanceof BELONGSTOMANY) {
belongsToManyList.push({
item,
target
@ -424,8 +430,8 @@ export abstract class Model extends SequelizeModel {
// 后处理 belongsToMany 的更新内容
if (belongsToManyList.length) {
const ThroughModel = (association as BelongsToMany).getThroughModel();
const throughName = (association as BelongsToMany).getThroughName();
const ThroughModel = (association as BELONGSTOMANY).getThroughModel();
const throughName = (association as BELONGSTOMANY).getThroughName();
for (const { item, target } of belongsToManyList) {
const throughValues = item[throughName];
@ -453,11 +459,11 @@ export abstract class Model extends SequelizeModel {
const table = this.database.getTable(this.constructor.name);
const association = table.getAssociations().get(key);
switch (true) {
case association instanceof BelongsTo:
case association instanceof HasOne:
case association instanceof BELONGSTO:
case association instanceof HASONE:
return this.updateSingleAssociation(key, data, options);
case association instanceof HasMany:
case association instanceof BelongsToMany:
case association instanceof HASMANY:
case association instanceof BELONGSTOMANY:
return this.updateMultipleAssociation(key, data, options);
}
}

8
packages/database/src/table.ts
View File

@ -10,8 +10,8 @@ import {
buildField,
FieldOptions,
Relation,
BelongsTo,
BelongsToMany,
BELONGSTO,
BELONGSTOMANY,
} from './fields';
import Database from './database';
import { Model, ModelCtor } from './model';
@ -166,7 +166,7 @@ export class Table {
if (this.database.isDefined(target)) {
const TargetModel = this.database.getModel(target);
// 如果关系表在之后才定义，未设置 targetKey 时，targetKey 默认值需要在 target model 初始化之后才能取到
if (association instanceof BelongsTo || association instanceof BelongsToMany) {
if (association instanceof BELONGSTO || association instanceof BELONGSTOMANY) {
association.updateOptionsAfterTargetModelBeDefined();
}
this.Model[type](TargetModel, association.getAssociationOptions());
@ -235,7 +235,7 @@ export class Table {
for (const association of this.associations.values()) {
const target = association.getTarget();
names.add(target);
if (association instanceof BelongsToMany) {
if (association instanceof BELONGSTOMANY) {
names.add(association.getThroughName());
}
}

4
packages/plugin-users/src/actions/login.ts
View File

@ -1,6 +1,6 @@
import { actions } from '@nocobase/actions';
import { PASSWORD } from '@nocobase/database';
import cryptoRandomString from 'crypto-random-string';
import { Password } from "@nocobase/database";
export default async (ctx: actions.Context, next: actions.Next) => {
const { values } = ctx.action.params;
@ -14,7 +14,7 @@ export default async (ctx: actions.Context, next: actions.Next) => {
if (!user) {
ctx.throw(401, 'Unauthorized');
}
if (!Password.verify(values.password, user.password)) {
if (!PASSWORD.verify(values.password, user.password)) {
ctx.throw(401, 'Unauthorized');
}
if (!user.token) {

12
packages/server/src/middleware.ts
View File

@ -2,7 +2,7 @@ import qs from 'qs';
import compose from 'koa-compose';
import { pathToRegexp } from 'path-to-regexp';
import Resourcer, { getNameByParams, KoaMiddlewareOptions, parseRequest, ResourcerContext } from '@nocobase/resourcer';
import Database, { BelongsTo, BelongsToMany, HasMany, HasOne } from '@nocobase/database';
import Database, { BELONGSTO, BELONGSTOMANY, HASMANY, HASONE } from '@nocobase/database';
interface MiddlewareOptions extends KoaMiddlewareOptions {
resourcer?: Resourcer;
@ -49,18 +49,18 @@ export function middleware(options: MiddlewareOptions = {}) {
}
if (database.isDefined(tableName)) {
const table = database.getTable(tableName);
const field = table.getField(names[0]) as BelongsTo | HasMany | BelongsToMany | HasOne;
const field = table.getField(names[0]) as BELONGSTO | HASMANY | BELONGSTOMANY | HASONE;
if (names.length == 0 || field) {
let resourceType = 'single';
let actions = {};
if (field) {
if (field instanceof HasOne) {
if (field instanceof HASONE) {
resourceType = 'hasOne';
} else if (field instanceof HasMany) {
} else if (field instanceof HASMANY) {
resourceType = 'hasMany';
} else if (field instanceof BelongsTo) {
} else if (field instanceof BELONGSTO) {
resourceType = 'belongsTo';
} else if (field instanceof BelongsToMany) {
} else if (field instanceof BELONGSTOMANY) {
resourceType = 'belongsToMany';
}
if (field.options.actions) {