fix: virtual column should not be added to unset in case of custom ge…

…tter cannot be serialize

src/adapters/sequelize.d.ts

@@ -1,8 +1,8 @@
 import { 
   Attributes, Literal, OperatorCondition, 
-  BoneOptions, ResultSet, Raw, Connection,
+  BoneOptions, ResultSet, Raw,
   SetOptions, BeforeHooksType, AfterHooksType,
-  QueryOptions, OrderOptions,
+  QueryOptions, OrderOptions, QueryResult
 } from '../types/common';
 import { AbstractBone } from '../types/bone';
 import { Spell } from '../spell';
@@ -131,13 +131,13 @@ export class SequelizeBone extends AbstractBone {
     this: T,
     fields: string | Array<string> | { [Property in keyof Extract<InstanceType<T>, Literal>]?: number },
     options?: SequelizeConditions<T>
-  ): Spell<T>;
+  ): Spell<T, QueryResult>;
 
   static increment<T extends typeof SequelizeBone>(
     this: T,
     fields: string | Array<string> | { [Property in keyof Extract<InstanceType<T>, Literal>]?: number },
     options?: SequelizeConditions<T>
-  ): Spell<T>;
+  ): Spell<T, QueryResult>;
 
   static max<T extends typeof SequelizeBone>(this: T, filed: string, options?: SequelizeConditions<T>): Promise<Literal>;
   static min<T extends typeof SequelizeBone>(this: T, filed: string, options?: SequelizeConditions<T>): Promise<Literal>;
@@ -179,8 +179,8 @@ export class SequelizeBone extends AbstractBone {
   previous(key?: string): Literal | Literal[] | { [key: string]: Literal | Literal[] };
   isSoftDeleted(): boolean;
 
-  increment(field: string | string[] | { [Property in keyof Extract<this, Literal>]?: number }, options?: QueryOptions): Spell<typeof SequelizeBone>;
-  decrement(field: string | string[] | { [Property in keyof Extract<this, Literal>]?: number }, options?: QueryOptions): Spell<typeof SequelizeBone>;
+  increment(field: string | string[] | { [Property in keyof Extract<this, Literal>]?: number }, options?: QueryOptions): Spell<typeof SequelizeBone, QueryResult>;
+  decrement(field: string | string[] | { [Property in keyof Extract<this, Literal>]?: number }, options?: QueryOptions): Spell<typeof SequelizeBone, QueryResult>;
   destroy(options?: SequelizeDestroyOptions): Promise<this| number>;
 }
 

src/bone.js

@@ -1291,8 +1291,8 @@ class Bone {
     }
 
     for (const name in attributes) {
-      const { columnName } = attributes[name];
-      if (!(columnName in row)) {
+      const attribute = attributes[name];
+      if (!(attribute.columnName in row) && !attribute.virtual) {
         instance._getRawUnset().add(name);
       }
     }

src/spell.d.ts

@@ -146,9 +146,9 @@ export class Spell<T extends typeof AbstractBone, U = InstanceType<T> | Collecti
   toString(): string;
 
   all: Spell<T, U>;
-  first: Spell<T, U>;
-  last: Spell<T, U>;
-  get(index: number): Spell<T, U>;
+  first: Spell<T, InstanceType<T>>;
+  last: Spell<T, InstanceType<T>>;
+  get(index: number): Spell<T, InstanceType<T>>;
 
   unscoped: Spell<T, U>;
   unparanoid: Spell<T, U>;

src/types/common.d.ts

@@ -148,8 +148,8 @@ type OrderOptions<T extends typeof AbstractBone> = {
 
 export class Collection<T extends AbstractBone> extends Array<T> {
   save(): Promise<void>;
-  toJSON(): Object[];
-  toObject(): Object[];
+  toJSON(): InstanceValues<T>[];
+  toObject(): InstanceValues<T>[];
 }
 
 export type WhereConditions<T extends typeof AbstractBone> = {

test/types/basics.test.ts

@@ -44,6 +44,11 @@ describe('=> Basics (TypeScript)', function() {
 
     @Column()
     wordCount: number;
+
+    @Column(DataTypes.VIRTUAL)
+    get isEmptyContent(): boolean {
+      return this.wordCount <= 0;
+    }
   }
 
   before(async function() {
@@ -95,13 +100,25 @@ describe('=> Basics (TypeScript)', function() {
 
   describe('=> Integration', function() {
     it('bone.toJSON()', async function() {
-      const post = await Post.create({ title: 'Nephalem' });
+      const post = await Post.create({ title: 'Nephalem', wordCount: 0 });
       assert.equal(post.toJSON().title, 'Nephalem');
+      // virtual column should not be added to unset
+      assert.equal(post.toJSON().isEmptyContent, true);
+      const post1 = await Post.findOne();
+      assert.equal(post1.toJSON().title, 'Nephalem');
+      // virtual column should not be added to unset
+      assert.equal(post1.toJSON().isEmptyContent, true);
     });
 
     it('bone.toObject()', async function() {
       const post = await Post.create({ title: 'Leah' });
       assert.equal(post.toObject().title, 'Leah');
+      // virtual column should not be added to unset
+      assert.equal(post.toObject().isEmptyContent, true);
+      const post1 = await Post.findOne();
+      assert.equal(post1.toObject().title, 'Leah');
+      // virtual column should not be added to unset
+      assert.equal(post1.toObject().isEmptyContent, true);
     });
   });
 
@@ -134,7 +151,7 @@ describe('=> Basics (TypeScript)', function() {
 
   describe('=> Read', function() {
     beforeEach(async function() {
-      const posts = await Post.bulkCreate([
+      await Post.bulkCreate([
         { title: 'Leah' },
         { title: 'Cain' },
         { title: 'Nephalem' }
@@ -162,6 +179,28 @@ describe('=> Basics (TypeScript)', function() {
       const posts = await Post.where({ title: { $like: '%a%' } }).select('title');
       assert.equal(posts.length, 3);
     });
+
+    it('first', async () => {
+      const post1 = await Post.find().first;
+      assert.equal(post1.title, 'Leah');
+    });
+
+    it('last', async () => {
+      const post1 = await Post.find().last;
+      assert.equal(post1.title, 'Nephalem');
+    });
+
+    it('get(index)', async () => {
+      const post1 = await Post.find().get(0);
+      assert.equal(post1.title, 'Leah');
+    });
+
+    it('all', async () => {
+      const posts = await Post.find().all;
+      assert.equal(posts.length, 3);
+      assert.equal(posts[0].title, 'Leah');
+    });
+
   });
 
   describe('=> Update', function() {

test/types/sequelize.test.ts

@@ -1387,4 +1387,4 @@ describe('=> sequelize (TypeScript)', function() {
     Like.removeAttribute('userId');
     assert(Like.attributes.userId == null);
   });
-});
+});