@nocobase/database 0.9.1-alpha.1 → 0.9.2-alpha.1

package/src/__tests__/repository.test.ts

@@ -181,6 +181,80 @@ describe('repository.find', () => {
   });
 });
 
+describe('repository create with belongs to many', () => {
+  let db: Database;
+
+  beforeEach(async () => {
+    db = mockDatabase({
+      tablePrefix: '',
+    });
+    await db.clean({ drop: true });
+  });
+
+  afterEach(async () => [await db.close()]);
+
+  it('should save value at through table', async () => {
+    const Product = db.collection({
+      name: 'products',
+      fields: [
+        { type: 'string', name: 'name' },
+        { type: 'integer', name: 'price' },
+      ],
+    });
+
+    const OrderProduct = db.collection({
+      name: 'orders_products',
+      fields: [{ type: 'integer', name: 'quantity' }],
+    });
+
+    const Order = db.collection({
+      name: 'orders',
+      fields: [
+        {
+          type: 'belongsToMany',
+          name: 'products',
+          through: 'orders_products',
+        },
+      ],
+    });
+
+    await db.sync();
+
+    await Product.repository.create({
+      values: [
+        {
+          name: 'product1',
+          price: 100,
+        },
+        {
+          name: 'product2',
+          price: 200,
+        },
+      ],
+    });
+
+    const p1 = await Product.repository.findOne({
+      filter: { name: 'product1' },
+    });
+
+    await Order.repository.create({
+      values: {
+        products: [
+          {
+            id: p1.get('id'),
+            orders_products: {
+              quantity: 20,
+            },
+          },
+        ],
+      },
+    });
+
+    const through = await OrderProduct.repository.findOne();
+    expect(through.get('quantity')).toBe(20);
+  });
+});
+
 describe('repository.create', () => {
   let db: Database;
   let User: Collection;
@@ -311,6 +385,20 @@ describe('repository.update', () => {
       name: 'post1',
       userId: user.id,
     });
+
+    await User.repository.update({
+      filterByTk: user.id,
+      values: {
+        posts: [{ name: 'post2' }, { name: 'post3' }],
+      },
+    });
+
+    const updated2 = await User.repository.findOne({
+      filterByTk: user.id,
+      appends: ['posts'],
+    });
+
+    expect(updated2.posts.length).toBe(2);
   });
 
   it('update2', async () => {

package/src/__tests__/sql-parser.test.ts

@@ -0,0 +1,13 @@
+import sqlParser from '../sql-parser';
+
+describe('sql parser', () => {
+  it('should parse sql', function () {
+    const sql = `select users.id as id from users`;
+    const { ast } = sqlParser.parse(sql);
+    const columns = ast.columns;
+    const firstColumn = columns[0];
+
+    expect(firstColumn['expr']['table']).toEqual('users');
+    expect(firstColumn['expr']['column']).toEqual('id');
+  });
+});

package/src/__tests__/tree.test.ts

@@ -0,0 +1,217 @@
+import { Database } from '../database';
+import { mockDatabase } from './';
+
+describe('sort', function () {
+  let db: Database;
+
+  beforeEach(async () => {
+    db = mockDatabase();
+  });
+
+  afterEach(async () => {
+    await db.close();
+  });
+
+  it('should be auto completed', () => {
+    const collection = db.collection({
+      name: 'categories',
+      tree: 'adjacency-list',
+      fields: [
+        {
+          type: 'belongsTo',
+          name: 'parent',
+          treeParent: true,
+        },
+        {
+          type: 'hasMany',
+          name: 'children',
+          treeChildren: true,
+        },
+      ],
+    });
+    expect(collection.treeChildrenField?.name).toBe('children');
+    expect(collection.treeParentField?.name).toBe('parent');
+    expect(collection.getField('parent').options.target).toBe('categories');
+    expect(collection.getField('parent').options.foreignKey).toBe('parentId');
+    expect(collection.getField('children').options.target).toBe('categories');
+    expect(collection.getField('children').options.foreignKey).toBe('parentId');
+  });
+
+  it('should be auto completed', () => {
+    const collection = db.collection({
+      name: 'categories',
+      tree: 'adjacency-list',
+      fields: [
+        {
+          type: 'belongsTo',
+          name: 'parent',
+          foreignKey: 'cid',
+          treeParent: true,
+        },
+        {
+          type: 'hasMany',
+          name: 'children',
+          foreignKey: 'cid',
+          treeChildren: true,
+        },
+      ],
+    });
+    expect(collection.treeChildrenField?.name).toBe('children');
+    expect(collection.treeParentField?.name).toBe('parent');
+    expect(collection.getField('parent').options.target).toBe('categories');
+    expect(collection.getField('parent').options.foreignKey).toBe('cid');
+    expect(collection.getField('children').options.target).toBe('categories');
+    expect(collection.getField('children').options.foreignKey).toBe('cid');
+  });
+
+  const values = [
+    {
+      name: '1',
+      __index: '0',
+      children: [
+        {
+          name: '1-1',
+          __index: '0.children.0',
+          children: [
+            {
+              name: '1-1-1',
+              __index: '0.children.0.children.0',
+              children: [
+                {
+                  name: '1-1-1-1',
+                  __index: '0.children.0.children.0.children.0',
+                },
+              ],
+            },
+          ],
+        },
+      ],
+    },
+    {
+      name: '2',
+      __index: '1',
+      children: [
+        {
+          name: '2-1',
+          __index: '1.children.0',
+          children: [
+            {
+              name: '2-1-1',
+              __index: '1.children.0.children.0',
+              children: [
+                {
+                  name: '2-1-1-1',
+                  __index: '1.children.0.children.0.children.0',
+                },
+              ],
+            },
+          ],
+        },
+      ],
+    },
+  ];
+
+  it('should be tree', async () => {
+    const collection = db.collection({
+      name: 'categories',
+      tree: 'adjacency-list',
+      fields: [
+        {
+          type: 'string',
+          name: 'name',
+        },
+        {
+          type: 'string',
+          name: 'description',
+        },
+        {
+          type: 'belongsTo',
+          name: 'parent',
+          treeParent: true,
+        },
+        {
+          type: 'hasMany',
+          name: 'children',
+          treeChildren: true,
+        },
+      ],
+    });
+    await db.sync();
+
+    await db.getRepository('categories').create({
+      values,
+    });
+
+    const instances = await db.getRepository('categories').find({
+      filter: {
+        parentId: null,
+      },
+      tree: true,
+      fields: ['id', 'name'],
+      sort: 'id',
+    });
+
+    expect(instances.map((i) => i.toJSON())).toMatchObject(values);
+
+    const instance = await db.getRepository('categories').findOne({
+      filterByTk: 1,
+      tree: true,
+      fields: ['id', 'name'],
+    });
+
+    expect(instance.toJSON()).toMatchObject(values[0]);
+  });
+
+  it('should be tree', async () => {
+    const collection = db.collection({
+      name: 'categories',
+      tree: 'adjacency-list',
+      fields: [
+        {
+          type: 'string',
+          name: 'name',
+        },
+        {
+          type: 'string',
+          name: 'description',
+        },
+        {
+          type: 'belongsTo',
+          name: 'parent',
+          foreignKey: 'cid',
+          treeParent: true,
+        },
+        {
+          type: 'hasMany',
+          name: 'children',
+          foreignKey: 'cid',
+          treeChildren: true,
+        },
+      ],
+    });
+    await db.sync();
+
+    await db.getRepository('categories').create({
+      values,
+    });
+
+    const instances = await db.getRepository('categories').find({
+      filter: {
+        cid: null,
+      },
+      tree: true,
+      fields: ['id', 'name'],
+      sort: 'id',
+    });
+
+    expect(instances.map((i) => i.toJSON())).toMatchObject(values);
+
+    const instance = await db.getRepository('categories').findOne({
+      filterByTk: 1,
+      tree: true,
+      fields: ['id', 'name'],
+    });
+
+    expect(instance.toJSON()).toMatchObject(values[0]);
+  });
+});

package/src/__tests__/view/list-view.test.ts

@@ -0,0 +1,34 @@
+import { Database, mockDatabase } from '@nocobase/database';
+
+describe('list view', () => {
+  let db: Database;
+
+  beforeEach(async () => {
+    db = mockDatabase({
+      tablePrefix: '',
+    });
+    await db.clean({ drop: true });
+  });
+
+  afterEach(async () => {
+    await db.close();
+  });
+
+  it('should list view', async () => {
+    const dropViewSQL1 = `DROP VIEW IF EXISTS test1`;
+    await db.sequelize.query(dropViewSQL1);
+
+    const dropViewSQL2 = `DROP VIEW IF EXISTS test2`;
+    await db.sequelize.query(dropViewSQL2);
+
+    const sql1 = `CREATE VIEW test1 AS SELECT 1`;
+    const sql2 = `CREATE VIEW test2 AS SELECT 2`;
+
+    await db.sequelize.query(sql1);
+    await db.sequelize.query(sql2);
+
+    const results = await db.queryInterface.listViews();
+    expect(results.find((item) => item.name === 'test1')).toBeTruthy();
+    expect(results.find((item) => item.name === 'test2')).toBeTruthy();
+  });
+});

package/src/__tests__/view/view-collection.test.ts

@@ -0,0 +1,199 @@
+import { Database, mockDatabase } from '@nocobase/database';
+import { uid } from '@nocobase/utils';
+import { ViewCollection } from '../../view-collection';
+
+describe('create view', () => {
+  let db: Database;
+
+  beforeEach(async () => {
+    db = mockDatabase({
+      tablePrefix: '',
+    });
+    await db.clean({ drop: true });
+  });
+
+  afterEach(async () => {
+    await db.close();
+  });
+
+  it('should create view collection in difference schema', async () => {
+    if (!db.inDialect('postgres')) return;
+    const schemaName = `t_${uid(6)}`;
+    const testSchemaSql = `CREATE SCHEMA IF NOT EXISTS ${schemaName};`;
+    await db.sequelize.query(testSchemaSql);
+
+    const viewName = 'test_view';
+
+    const viewSQL = `CREATE OR REPLACE VIEW ${schemaName}.test_view AS SELECT 1+1 as result`;
+    await db.sequelize.query(viewSQL);
+
+    const viewCollection = db.collection({
+      name: viewName,
+      schema: schemaName,
+      view: true,
+      fields: [
+        {
+          type: 'string',
+          name: 'result',
+        },
+      ],
+    });
+
+    const results = await viewCollection.repository.find();
+
+    expect(results.length).toBe(1);
+  });
+
+  it('should create view collection', async () => {
+    const UserCollection = db.collection({
+      name: 'users',
+      fields: [
+        {
+          type: 'string',
+          name: 'name',
+        },
+        {
+          type: 'hasOne',
+          name: 'profile',
+          foreignKey: 'user_id',
+        },
+      ],
+    });
+
+    const ProfileCollection = db.collection({
+      name: 'profiles',
+      fields: [
+        {
+          type: 'integer',
+          name: 'age',
+        },
+        {
+          type: 'belongsTo',
+          name: 'user',
+          foreignKey: 'user_id',
+        },
+      ],
+    });
+
+    await db.sync();
+
+    await UserCollection.repository.create({
+      values: {
+        name: 'foo',
+        profile: {
+          age: 18,
+        },
+      },
+    });
+    const schema = UserCollection.collectionSchema();
+    const viewName = 'users_with_profile';
+
+    const appendSchema = db.inDialect('postgres') ? `"${schema}".` : '';
+
+    const dropViewSQL = `DROP VIEW IF EXISTS ${appendSchema}${viewName}`;
+    await db.sequelize.query(dropViewSQL);
+    const viewSql = `CREATE  VIEW ${appendSchema}${viewName} AS SELECT users.name, profiles.age FROM ${appendSchema}${UserCollection.model.tableName} as users LEFT JOIN ${appendSchema}${ProfileCollection.model.tableName} as profiles ON users.id = profiles.user_id;`;
+
+    await db.sequelize.query(viewSql);
+
+    db.collection({
+      name: viewName,
+      view: true,
+      fields: [
+        {
+          type: 'string',
+          name: 'name',
+        },
+        {
+          type: 'integer',
+          name: 'age',
+        },
+      ],
+    });
+    const UserWithProfileView = db.getCollection(viewName);
+    expect(UserWithProfileView).toBeInstanceOf(ViewCollection);
+
+    const fooData = await UserWithProfileView.repository.findOne({
+      filter: {
+        name: 'foo',
+      },
+    });
+
+    console.log(fooData);
+    expect(fooData.get('name')).toBe('foo');
+    expect(fooData.get('age')).toBe(18);
+  });
+
+  it('should not sync view collection', async () => {
+    const dropViewSQL = `DROP VIEW IF EXISTS test_view`;
+    await db.sequelize.query(dropViewSQL);
+
+    const viewSql = `CREATE VIEW test_view AS SELECT 1+1 as result`;
+
+    await db.sequelize.query(viewSql);
+    const viewCollection = db.collection({
+      name: 'view_collection',
+      viewName: 'test_view',
+      fields: [
+        {
+          type: 'string',
+          name: 'result',
+        },
+      ],
+    });
+
+    const jestFn = jest.fn();
+
+    db.on('beforeSync', jestFn);
+
+    await viewCollection.sync();
+    expect(jestFn).not.toBeCalled();
+  });
+
+  it('should create view collection with source field options', async () => {
+    const UserCollection = db.collection({
+      name: 'users',
+      fields: [
+        {
+          name: 'name',
+          type: 'string',
+          patterns: [
+            {
+              type: 'integer',
+              options: { key: 1 },
+            },
+          ],
+        },
+      ],
+    });
+
+    await db.sync();
+
+    const viewName = 'users_view';
+
+    const dropViewSQL = `DROP VIEW IF EXISTS ${viewName}`;
+    await db.sequelize.query(dropViewSQL);
+
+    const viewSQL = `
+       CREATE VIEW ${viewName} as SELECT users.* FROM ${UserCollection.quotedTableName()} as users
+    `;
+
+    await db.sequelize.query(viewSQL);
+
+    // create view collection
+    const ViewCollection = db.collection({
+      name: viewName,
+      view: true,
+      fields: [
+        {
+          name: 'name',
+          type: 'string',
+          source: 'users.name',
+        },
+      ],
+    });
+
+    const viewNameField = ViewCollection.getField('name');
+    expect(viewNameField.options.patterns).toEqual(UserCollection.getField('name').options.patterns);
+  });
+});

package/src/__tests__/view/view-inference.test.ts

@@ -0,0 +1,145 @@
+import { Database, mockDatabase } from '@nocobase/database';
+import { ViewFieldInference } from '../../view/view-inference';
+
+describe('view inference', function () {
+  let db: Database;
+
+  beforeEach(async () => {
+    db = mockDatabase({
+      tablePrefix: '',
+    });
+    await db.clean({ drop: true });
+  });
+
+  afterEach(async () => {
+    await db.close();
+  });
+
+  it('should infer field with alias', async () => {
+    if (db.options.dialect !== 'postgres') return;
+
+    const UserCollection = db.collection({
+      name: 'users',
+      fields: [
+        {
+          name: 'id',
+          type: 'bigInt',
+          interface: 'bigInt',
+        },
+        {
+          name: 'name',
+          type: 'string',
+          interface: 'test',
+        },
+      ],
+    });
+
+    await db.sync();
+
+    const viewName = 'user_posts';
+
+    const dropViewSQL = `DROP VIEW IF EXISTS ${viewName}`;
+    await db.sequelize.query(dropViewSQL);
+
+    const viewSQL = `
+       CREATE VIEW ${viewName} as SELECT 1 as const_field, users.id as user_id_field, users.name FROM ${UserCollection.quotedTableName()} as users
+    `;
+
+    await db.sequelize.query(viewSQL);
+
+    const inferredFields = await ViewFieldInference.inferFields({
+      db,
+      viewName,
+      viewSchema: 'public',
+    });
+
+    expect(inferredFields['user_id_field'].source).toBe('users.id');
+    expect(inferredFields['name'].source).toBe('users.name');
+  });
+
+  it('should infer collection fields', async () => {
+    const UserCollection = db.collection({
+      name: 'users',
+      fields: [
+        {
+          name: 'name',
+          type: 'string',
+          interface: 'test',
+        },
+        {
+          name: 'age',
+          type: 'integer',
+          interface: 'test',
+        },
+        {
+          name: 'profile',
+          type: 'json',
+          interface: 'test',
+        },
+        {
+          name: 'posts',
+          type: 'hasMany',
+          interface: 'test',
+        },
+      ],
+    });
+
+    const PostCollection = db.collection({
+      name: 'posts',
+      fields: [
+        {
+          name: 'title',
+          type: 'string',
+          interface: 'test',
+        },
+        {
+          name: 'user',
+          type: 'belongsTo',
+          interface: 'test',
+        },
+      ],
+    });
+
+    await db.sync();
+
+    const viewName = 'user_posts';
+
+    const dropViewSQL = `DROP VIEW IF EXISTS ${viewName}`;
+    await db.sequelize.query(dropViewSQL);
+
+    const viewSQL = `
+       CREATE VIEW ${viewName} as SELECT 1 as const_field, users.* FROM ${UserCollection.quotedTableName()} as users
+    `;
+
+    await db.sequelize.query(viewSQL);
+
+    const inferredFields = await ViewFieldInference.inferFields({
+      db,
+      viewName,
+      viewSchema: 'public',
+    });
+
+    const createdAt = UserCollection.model.rawAttributes['createdAt'].field;
+    expect(inferredFields[createdAt]['type']).toBe('date');
+
+    if (db.options.dialect == 'sqlite') {
+      expect(inferredFields['name']).toMatchObject({
+        name: 'name',
+        type: 'string',
+      });
+    } else {
+      expect(inferredFields['name']).toMatchObject({
+        name: 'name',
+        type: 'string',
+        source: 'users.name',
+      });
+
+      expect(inferredFields['const_field']).toMatchObject({
+        name: 'const_field',
+        type: 'integer',
+      });
+    }
+
+    await db.sequelize.query(dropViewSQL);
+  });
+});