@nocobase/database 0.7.4-alpha.4 → 0.7.5-alpha.1

package/src/__tests__/field-options/inddex.test.ts

@@ -0,0 +1,43 @@
+import { mockDatabase } from '../';
+import { Database } from '../../database';
+import { md5 } from '../../utils';
+
+describe('index field options', () => {
+  let db: Database;
+
+  beforeEach(async () => {
+    db = mockDatabase();
+  });
+
+  afterEach(async () => {
+    await db.close();
+  });
+
+  it('case 1', async () => {
+    const t1 = 't1234567890223456789032345678904234567890523456789';
+    const f1 = 'f1234567890223456789032345678904234567890523456789062345678901';
+    const f2 = 'f1234567890223456789032345678904234567890523456789062345678902';
+    db.collection({
+      name: t1,
+      fields: [
+        {
+          type: 'string',
+          name: f1,
+          index: true,
+        },
+        {
+          type: 'string',
+          name: f2,
+          index: true,
+        },
+      ],
+    });
+    await db.sync();
+    // @ts-ignore
+    const indexes = db.getModel(t1)._indexes;
+    const index1 = indexes.find((item) => item.fields.includes(f1));
+    const index2 = indexes.find((item) => item.fields.includes(f2));
+    expect('i_' + md5(db.getTablePrefix() + `${t1}_${f1}`)).toBe(index1.name);
+    expect('i_' + md5(db.getTablePrefix() + `${t1}_${f2}`)).toBe(index2.name);
+  });
+});

package/src/__tests__/fields/array.test.ts

@@ -0,0 +1,66 @@
+import { mockDatabase } from '../';
+import { Database } from '../../database';
+
+describe('array field', () => {
+  let db: Database;
+
+  beforeEach(async () => {
+    db = mockDatabase();
+  });
+
+  afterEach(async () => {
+    await db.close();
+  });
+
+  it('should not be ambiguous', async () => {
+    db.collection({
+      name: 'a',
+      fields: [
+        {
+          type: 'array',
+          name: 'arr',
+        },
+        {
+          type: 'belongsToMany',
+          name: 'b',
+          target: 'b',
+        },
+      ],
+    });
+    db.collection({
+      name: 'b',
+      fields: [
+        {
+          type: 'array',
+          name: 'arr',
+        },
+      ],
+    });
+    await db.sync();
+    const repository = db.getRepository('a');
+    await repository.find({
+      filter: {
+        'arr.$match': ['aa'],
+      },
+      appends: ['b'],
+    });
+    await repository.find({
+      filter: {
+        'arr.$notMatch': ['aa'],
+      },
+      appends: ['b'],
+    });
+    await repository.find({
+      filter: {
+        'arr.$anyOf': ['aa'],
+      },
+      appends: ['b'],
+    });
+    await repository.find({
+      filter: {
+        'arr.$noneOf': ['aa'],
+      },
+      appends: ['b'],
+    });
+  });
+});

package/src/__tests__/fields/belongs-to-field.test.ts

@@ -1,5 +1,6 @@
 import { Database } from '../../database';
 import { mockDatabase } from '../';
+import { IdentifierError } from '../../errors/identifier-error';
 
 describe('belongs to field', () => {
   let db: Database;
@@ -28,12 +29,16 @@ describe('belongs to field', () => {
         { type: 'belongsTo', name: 'post' },
       ],
     });
+
     expect(Comment.model.associations.post).toBeUndefined();
+
     const Post = db.collection({
       name: 'posts',
       fields: [{ type: 'string', name: 'title' }],
     });
+
     const association = Comment.model.associations.post;
+
     expect(Comment.model.associations.post).toBeDefined();
     expect(association.foreignKey).toBe('postId');
     // @ts-ignore
@@ -77,11 +82,41 @@ describe('belongs to field', () => {
     const association = Comment.model.associations.post;
     expect(association).toBeDefined();
     expect(association.foreignKey).toBe('postKey');
+
     // @ts-ignore
     expect(association.targetKey).toBe('key');
     expect(Comment.model.rawAttributes['postKey']).toBeDefined();
   });
 
+  it('should throw error when foreignKey is too long', async () => {
+    const Post = db.collection({
+      name: 'posts',
+      fields: [{ type: 'string', name: 'key', unique: true }],
+    });
+
+    const longForeignKey = 'a'.repeat(128);
+
+    let error;
+
+    try {
+      const Comment = db.collection({
+        name: 'comments1',
+        fields: [
+          {
+            type: 'belongsTo',
+            name: 'post',
+            targetKey: 'key',
+            foreignKey: longForeignKey,
+          },
+        ],
+      });
+    } catch (e) {
+      error = e;
+    }
+
+    expect(error).toBeInstanceOf(IdentifierError);
+  });
+
   it('custom name and target', async () => {
     const Comment = db.collection({
       name: 'comments',

package/src/__tests__/fields/belongs-to-many-field.test.ts

@@ -1,5 +1,6 @@
 import { mockDatabase } from '../';
 import { Database } from '../../database';
+import { IdentifierError } from '../../errors/identifier-error';
 
 describe('belongs to many field', () => {
   let db: Database;
@@ -58,4 +59,48 @@ describe('belongs to many field', () => {
     expect(PostTag.model.rawAttributes['postId']).toBeDefined();
     expect(PostTag.model.rawAttributes['tagId']).toBeDefined();
   });
+
+  it('should throw error when foreignKey is too long', async () => {
+    const Post = db.collection({
+      name: 'posts',
+      fields: [
+        { type: 'string', name: 'name' },
+        { type: 'belongsToMany', name: 'tags', foreignKey: 'a'.repeat(128) },
+      ],
+    });
+
+    let error;
+    try {
+      const Tag = db.collection({
+        name: 'tags',
+        fields: [{ type: 'string', name: 'name' }],
+      });
+    } catch (e) {
+      error = e;
+    }
+
+    expect(error).toBeInstanceOf(IdentifierError);
+  });
+
+  it('should throw error when through is too long', async () => {
+    const Post = db.collection({
+      name: 'posts',
+      fields: [
+        { type: 'string', name: 'name' },
+        { type: 'belongsToMany', name: 'tags', through: 'a'.repeat(128) },
+      ],
+    });
+
+    let error;
+    try {
+      const Tag = db.collection({
+        name: 'tags',
+        fields: [{ type: 'string', name: 'name' }],
+      });
+    } catch (e) {
+      error = e;
+    }
+
+    expect(error).toBeInstanceOf(IdentifierError);
+  });
 });

package/src/__tests__/fields/has-many-field.test.ts

@@ -1,6 +1,7 @@
 import { Database } from '../../database';
 import { mockDatabase } from '../';
 import { makeWatchHost } from 'ts-loader/dist/servicesHost';
+import { IdentifierError } from '../../errors/identifier-error';
 
 describe('has many field', () => {
   let db: Database;
@@ -149,4 +150,25 @@ describe('has many field', () => {
     Comment.removeField('post');
     expect(Comment.model.rawAttributes.postId).toBeUndefined();
   });
+
+  it('should throw error when foreignKey is too long', async () => {
+    const longForeignKey = 'a'.repeat(64);
+
+    const Post = db.collection({
+      name: 'posts',
+      fields: [{ type: 'hasMany', name: 'comments', foreignKey: longForeignKey }],
+    });
+
+    let error;
+    try {
+      const Comment = db.collection({
+        name: 'comments',
+        fields: [{ type: 'belongsTo', name: 'post' }],
+      });
+    } catch (e) {
+      error = e;
+    }
+
+    expect(error).toBeInstanceOf(IdentifierError);
+  });
 });

package/src/__tests__/fields/has-one-field.test.ts

@@ -1,5 +1,6 @@
 import { Database } from '../../database';
 import { mockDatabase } from '../';
+import { IdentifierError } from '../../errors/identifier-error';
 
 describe('has many field', () => {
   let db: Database;
@@ -64,4 +65,24 @@ describe('has many field', () => {
     Profile.removeField('user');
     expect(Profile.model.rawAttributes.userId).toBeUndefined();
   });
+
+  it('should throw error when foreignKey is too long', async () => {
+    const longForeignKey = 'a'.repeat(128);
+
+    const User = db.collection({
+      name: 'users',
+      fields: [{ type: 'hasOne', name: 'profile', foreignKey: longForeignKey }],
+    });
+
+    let error;
+    try {
+      const Profile = db.collection({
+        name: 'profiles',
+        fields: [{ type: 'belongsTo', name: 'user' }],
+      });
+    } catch (e) {
+      error = e;
+    }
+    expect(error).toBeInstanceOf(IdentifierError);
+  });
 });