@nocobase/database 0.5.0-alpha.38 → 0.7.0-alpha.2

package/src/__tests__/update-guard.test.ts

@@ -0,0 +1,376 @@
+import { Collection } from '../collection';
+import { mockDatabase } from './index';
+import { UpdateGuard } from '../update-guard';
+import lodash from 'lodash';
+import { Database } from '../database';
+
+describe('update-guard', () => {
+  let db: Database;
+  let User: Collection;
+  let Post: Collection;
+  let Comment: Collection;
+
+  beforeEach(async () => {
+    db = mockDatabase();
+
+    User = db.collection({
+      name: 'users',
+      fields: [
+        { type: 'string', name: 'name' },
+        { type: 'integer', name: 'age' },
+        { type: 'hasMany', name: 'posts' },
+      ],
+    });
+
+    Post = db.collection({
+      name: 'posts',
+      fields: [
+        { type: 'string', name: 'title' },
+        { type: 'string', name: 'content' },
+        {
+          type: 'belongsTo',
+          name: 'user',
+        },
+        {
+          type: 'hasMany',
+          name: 'comments',
+        },
+      ],
+    });
+
+    Comment = db.collection({
+      name: 'comments',
+      fields: [
+        { type: 'string', name: 'content' },
+        { type: 'string', name: 'comment_as' },
+        { type: 'belongsTo', name: 'post' },
+      ],
+    });
+
+    await db.sync({
+      force: true,
+      alter: { drop: false },
+    });
+
+    const repository = User.repository;
+
+    await repository.createMany({
+      records: [
+        {
+          name: 'u1',
+          age: 10,
+          posts: [{ title: 'u1t1', comments: [{ content: 'u1t1c1' }] }],
+        },
+        {
+          name: 'u2',
+          age: 20,
+          posts: [{ title: 'u2t1', comments: [{ content: 'u2t1c1' }] }],
+        },
+        {
+          name: 'u3',
+          age: 30,
+          posts: [{ title: 'u3t1', comments: [{ content: 'u3t1c1' }] }],
+        },
+      ],
+    });
+  });
+
+  afterEach(async () => {
+    await db.close();
+  });
+
+  test('white list', () => {
+    const values = {
+      name: '123',
+      age: 30,
+    };
+    const guard = new UpdateGuard();
+    guard.setModel(User.model);
+    guard.setWhiteList(['name']);
+
+    expect(guard.sanitize(values)).toEqual({
+      name: '123',
+    });
+  });
+
+  test('black list', () => {
+    const values = {
+      name: '123',
+      age: 30,
+    };
+
+    const guard = new UpdateGuard();
+    guard.setModel(User.model);
+    guard.setBlackList(['name']);
+
+    expect(guard.sanitize(values)).toEqual({
+      age: 30,
+    });
+  });
+
+  test('association black list', () => {
+    const values = {
+      name: 'username123',
+      age: 30,
+      posts: [
+        {
+          title: 'post-title123',
+          content: '345',
+        },
+      ],
+    };
+
+    const guard = new UpdateGuard();
+    guard.setModel(User.model);
+    guard.setBlackList(['name', 'posts']);
+
+    expect(guard.sanitize(values)).toEqual({
+      age: 30,
+    });
+  });
+
+  test('association fields black list', () => {
+    const values = {
+      name: 'username123',
+      age: 30,
+      posts: [
+        {
+          title: 'post-title123',
+          content: '345',
+        },
+      ],
+    };
+
+    const guard = new UpdateGuard();
+    guard.setModel(User.model);
+    guard.setBlackList(['name', 'posts.content']);
+
+    expect(guard.sanitize(values)).toEqual({
+      age: 30,
+      posts: values.posts.map((p) => {
+        return {
+          title: p.title,
+        };
+      }),
+    });
+  });
+
+  test('association subfield white list', () => {
+    const values = {
+      name: 'username123',
+      age: 30,
+      posts: [
+        {
+          title: 'post-title123',
+          content: '345',
+        },
+      ],
+    };
+
+    const guard = new UpdateGuard();
+    guard.setModel(User.model);
+    guard.setWhiteList(['name', 'posts.title']);
+
+    expect(guard.sanitize(values)).toEqual({
+      name: values.name,
+      posts: values.posts.map((post) => {
+        return {
+          title: post.title,
+        };
+      }),
+    });
+  });
+
+  test('association nested fields white list', () => {
+    const values = {
+      name: 'username123',
+      age: 30,
+      posts: [
+        {
+          title: 'post-title123',
+          content: '345',
+          comments: [1, 2, 3],
+        },
+      ],
+    };
+
+    const guard = new UpdateGuard();
+    guard.setModel(User.model);
+    guard.setWhiteList(['name', 'posts.comments']);
+
+    expect(guard.sanitize(values)).toEqual({
+      name: values.name,
+      posts: values.posts.map((post) => {
+        return {
+          comments: post.comments,
+        };
+      }),
+    });
+  });
+
+  test('association white list', () => {
+    const values = {
+      name: '123',
+      age: 30,
+      posts: [
+        {
+          title: '123',
+          content: '345',
+        },
+      ],
+    };
+
+    const guard = new UpdateGuard();
+    guard.setModel(User.model);
+    guard.setWhiteList(['posts']);
+
+    expect(guard.sanitize(values)).toEqual({
+      posts: values.posts,
+    });
+  });
+
+  test('associationKeysToBeUpdate', () => {
+    const values = {
+      name: '123',
+      age: 30,
+      posts: [
+        {
+          title: '123',
+          content: '345',
+        },
+        {
+          id: 1,
+          title: '456',
+          content: '789',
+        },
+      ],
+    };
+
+    const guard = new UpdateGuard();
+    guard.setModel(User.model);
+
+    expect(guard.sanitize(values)).toEqual({
+      name: '123',
+      age: 30,
+      posts: [
+        {
+          title: '123',
+          content: '345',
+        },
+        {
+          id: 1,
+        },
+      ],
+    });
+
+    guard.setAssociationKeysToBeUpdate(['posts']);
+    expect(guard.sanitize(values)).toEqual(values);
+  });
+
+  test('associationKeysToBeUpdate nested association', () => {
+    const values = {
+      name: '123',
+      age: 30,
+      posts: [
+        {
+          title: '123',
+          content: '345',
+        },
+        {
+          id: 1,
+          title: '456',
+          content: '789',
+          comments: [
+            {
+              id: 1,
+              content: '123',
+            },
+          ],
+        },
+      ],
+    };
+
+    const guard = new UpdateGuard();
+    guard.setModel(User.model);
+
+    expect(guard.sanitize(lodash.clone(values))).toEqual({
+      name: '123',
+      age: 30,
+      posts: [
+        {
+          title: '123',
+          content: '345',
+        },
+        {
+          id: 1,
+          comments: [
+            {
+              id: 1,
+            },
+          ],
+        },
+      ],
+    });
+
+    guard.setAssociationKeysToBeUpdate(['posts']);
+
+    expect(guard.sanitize(lodash.clone(values))).toEqual({
+      name: '123',
+      age: 30,
+      posts: [
+        {
+          title: '123',
+          content: '345',
+        },
+        {
+          id: 1,
+          title: '456',
+          content: '789',
+          comments: [
+            {
+              id: 1,
+            },
+          ],
+        },
+      ],
+    });
+  });
+});
+
+describe('One2One Association', () => {
+  test('associationKeysToBeUpdate hasOne & BelongsTo', () => {
+    const db = mockDatabase();
+    const Post = db.collection({
+      name: 'posts',
+      fields: [{ type: 'belongsTo', name: 'user', targetKey: 'uid' }],
+    });
+
+    const User = db.collection({
+      name: 'users',
+      fields: [{ type: 'string', name: 'uid', unique: true }],
+    });
+
+    const values = {
+      title: '123',
+      content: '456',
+      user: {
+        uid: 1,
+        name: '123',
+      },
+    };
+
+    const guard = new UpdateGuard();
+    guard.setModel(Post.model);
+
+    expect(guard.sanitize(values)).toEqual({
+      title: '123',
+      content: '456',
+      user: {
+        uid: 1,
+      },
+    });
+
+    guard.setAssociationKeysToBeUpdate(['user']);
+    expect(guard.sanitize(values)).toEqual(values);
+  });
+});

package/src/collection-importer.ts

@@ -0,0 +1,49 @@
+import * as fs from 'fs';
+import lodash from 'lodash';
+import path from 'path';
+
+export type ImportFileExtension = 'js' | 'ts' | 'json';
+
+async function requireModule(module: any) {
+  if (typeof module === 'string') {
+    module = require(module);
+  }
+
+  if (typeof module !== 'object') {
+    return module;
+  }
+  return module.__esModule ? module.default : module;
+}
+
+export class ImporterReader {
+  directory: string;
+  extensions: Set<string>;
+
+  constructor(directory: string, extensions?: ImportFileExtension[]) {
+    this.directory = directory;
+
+    if (!extensions) {
+      extensions = ['js', 'ts', 'json'];
+    }
+
+    this.extensions = new Set(extensions);
+  }
+
+  async read() {
+    const modules = (
+      await fs.promises.readdir(this.directory, {
+        encoding: 'utf-8',
+      })
+    )
+      .filter((fileName) => {
+        if (fileName.endsWith('.d.ts')) {
+          return false;
+        }
+        const ext = path.parse(fileName).ext.replace('.', '');
+        return this.extensions.has(ext);
+      })
+      .map(async (fileName) => await requireModule(path.join(this.directory, fileName)));
+
+    return (await Promise.all(modules)).filter((module) => lodash.isPlainObject(module));
+  }
+}

package/src/collection.ts

@@ -0,0 +1,282 @@
+import merge from 'deepmerge';
+import { EventEmitter } from 'events';
+import { default as lodash, default as _ } from 'lodash';
+import { col, ModelCtor, ModelOptions, SyncOptions } from 'sequelize';
+import { Database } from './database';
+import { Field, FieldOptions } from './fields';
+import { Model } from './model';
+import { Repository } from './repository';
+
+export type RepositoryType = typeof Repository;
+
+export type CollectionSortable = string | boolean | { name?: string; scopeKey?: string };
+
+export interface CollectionOptions extends Omit<ModelOptions, 'name' | 'hooks'> {
+  name: string;
+  tableName?: string;
+  filterTargetKey?: string;
+  fields?: FieldOptions[];
+  model?: string | ModelCtor<Model>;
+  repository?: string | RepositoryType;
+  sortable?: CollectionSortable;
+  /**
+   * @default true
+   */
+  autoGenId?: boolean;
+  /**
+   * @default 'options'
+   */
+  magicAttribute?: 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: ModelCtor<Model>;
+  repository: Repository<TModelAttributes, TCreationAttributes>;
+
+  get filterTargetKey() {
+    return lodash.get(this.options, 'filterTargetKey', this.model.primaryKeyAttribute);
+  }
+
+  get name() {
+    return this.options.name;
+  }
+
+  constructor(options: CollectionOptions, context?: CollectionContext) {
+    super();
+    this.context = context;
+    this.options = options;
+    this.bindFieldEventListener();
+    this.modelInit();
+    this.setFields(options.fields);
+    this.setRepository(options.repository);
+    this.setSortable(options.sortable);
+  }
+
+  private sequelizeModelOptions() {
+    const { name, tableName } = this.options;
+    return {
+      ..._.omit(this.options, ['name', 'fields', 'model', 'targetKey']),
+      modelName: name,
+      sequelize: this.context.database.sequelize,
+      tableName: tableName || name,
+    };
+  }
+
+  /**
+   * TODO
+   */
+  modelInit() {
+    if (this.model) {
+      return;
+    }
+    const { name, model, autoGenId = true } = this.options;
+    let M: ModelCtor<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;
+    }
+    this.repository = new repo(this);
+  }
+
+  private bindFieldEventListener() {
+    this.on('field.afterAdd', (field: Field) => {
+      field.bind();
+    });
+    this.on('field.afterRemove', (field) => field.unbind());
+  }
+
+  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);
+  }
+
+  setField(name: string, options: FieldOptions): Field {
+    const { database } = this.context;
+
+    const field = database.buildField(
+      { name, ...options },
+      {
+        ...this.context,
+        collection: this,
+      },
+    );
+    this.removeField(name);
+    this.fields.set(name, field);
+    this.emit('field.afterAdd', field);
+    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);
+    }
+  }
+
+  removeField(name) {
+    if (!this.fields.has(name)) {
+      return;
+    }
+    const field = this.fields.get(name);
+    const bool = this.fields.delete(name);
+    if (bool) {
+      this.emit('field.afterRemove', field);
+    }
+    return bool;
+  }
+
+  /**
+   * 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.setFields(options.fields, false);
+    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);
+  }
+
+  async sync(syncOptions?: SyncOptions) {
+    const modelNames = [this.model.name];
+
+    const associations = this.model.associations;
+
+    for (const associationKey in associations) {
+      const association = associations[associationKey];
+      modelNames.push(association.target.name);
+      if ((<any>association).through) {
+        modelNames.push((<any>association).through.model.name);
+      }
+    }
+
+    const models: ModelCtor<Model>[] = [];
+    // @ts-ignore
+    this.context.database.sequelize.modelManager.forEachModel((model) => {
+      if (modelNames.includes(model.name)) {
+        models.push(model);
+      }
+    });
+
+    for (const model of models) {
+      await model.sync(syncOptions);
+    }
+  }
+}