fix column names (#61)

Author: mariarek

package.json

@@ -1,6 +1,6 @@
 {
   "name": "nosqlprovider",
-  "version": "0.6.17",
+  "version": "0.6.18",
   "description": "A cross-browser/platform indexeddb-like client library",
   "author": "David de Regt <David.de.Regt@microsoft.com>",
   "scripts": {

src/SqlProviderBase.ts

@@ -318,8 +318,8 @@ export abstract class SqlProviderBase extends NoSqlProvider.DbProvider {
                             const columnBasedIndices = _.filter(storeSchema.indexes, index =>
                                 !indexUsesSeparateTable(index, this._supportsFTS3));
 
-                            const indexColumns = _.map(columnBasedIndices, index => 'nsp_i_' + index.name + ' TEXT');
-                            fieldList = fieldList.concat(indexColumns);
+                            const indexColumnsNames = _.map(columnBasedIndices, index => 'nsp_i_' + index.name + ' TEXT');
+                            fieldList = fieldList.concat(indexColumnsNames);
                             const tableMakerSql = 'CREATE TABLE ' + storeSchema.name + ' (' + fieldList.join(', ') + ')';
 
                             const currentIndexMetas = _.filter(indexMetadata, meta => meta.storeName === storeSchema.name);
@@ -331,6 +331,8 @@ export abstract class SqlProviderBase extends NoSqlProvider.DbProvider {
                             const [newIndices, existingIndices] = _.partition(storeSchema.indexes, index =>
                                 !indexMetaDictionary[getIndexIdentifier(storeSchema, index)]);
 
+                            const existingIndexColumns = _.intersection(existingIndices, columnBasedIndices);
+
                             // find indices in the meta that do not exist in the new schema
                             const allRemovedIndexMetas = _.filter(currentIndexMetas, meta => 
                                 !indexIdentifierDictionary[meta.key]);
@@ -471,10 +473,10 @@ export abstract class SqlProviderBase extends NoSqlProvider.DbProvider {
                             if (doSqlInPlaceMigration) {
                                 const sqlInPlaceMigrator = () => {
                                     const columnsToCopy = ['nsp_pk', 'nsp_data',  
-                                        ..._.map(existingIndices, index => getIndexIdentifier(storeSchema, index))
+                                        ..._.map(existingIndexColumns, index => 'nsp_i_' + index.name)
                                     ].join(', ');
 
-                                    return trans.runQuery('INSERT INTO ' + storeSchema.name + '(' + columnsToCopy + ')' +
+                                    return trans.runQuery('INSERT INTO ' + storeSchema.name + ' (' + columnsToCopy + ')' +
                                         ' SELECT ' + columnsToCopy + 
                                         ' FROM temp_' + storeSchema.name);
                                 };

src/tests/NoSqlProviderTests.ts

@@ -2284,6 +2284,76 @@ describe('NoSqlProvider', function () {
                                 });
                             });
                         });
+
+                        it('Add remove index in the same upgrade, while preserving other indices', () => {
+                            return openProvider(provName, {
+                                version: 1,
+                                stores: [
+                                    {
+                                        name: 'test',
+                                        primaryKeyPath: 'id',
+                                        indexes: [{
+                                            name: 'ind1',
+                                            keyPath: 'tt',
+                                            doNotBackfill: true
+                                        }, {
+                                            name: 'ind2',
+                                            keyPath: 'zz',
+                                            doNotBackfill: true
+                                        }]
+                                    }
+                                ]
+                            }, true)
+                            .then(prov => {
+                                return prov.put('test', { id: 'abc', tt: 'a' , zz: 'aa'}).then(() => {
+                                    return prov.close();
+                                });
+                            })
+                            .then(() => {
+                                return openProvider(provName, {
+                                    version: 2,
+                                    stores: [
+                                        {
+                                            name: 'test',
+                                            primaryKeyPath: 'id',
+                                            indexes: [{
+                                                name: 'ind2',
+                                                keyPath: 'zz',
+                                                doNotBackfill: true
+                                            }, {
+                                                name: 'ind3',
+                                                keyPath: 'zz',
+                                                doNotBackfill: true
+                                            }]
+                                        }
+                                    ]
+                                }, false)
+                                .then(prov => {
+                                    const p1 = prov.getOnly('test', undefined, 'abc').then((items: any[]) => {
+                                        assert.equal(items.length, 1);
+                                        assert.equal(items[0].id, 'abc');
+                                        assert.equal(items[0].tt, 'a');
+                                        assert.equal(items[0].zz, 'aa');
+                                    });
+                                    const p2 = prov.getOnly('test', 'ind2', 'aa').then((items: any[]) => {
+                                        assert.equal(items.length, 1);
+                                        assert.equal(items[0].id, 'abc');
+                                        assert.equal(items[0].tt, 'a');
+                                        assert.equal(items[0].zz, 'aa');
+                                    });
+                                    const p3 = prov.getOnly('test', 'ind1', 'a').then(items => {
+                                        return SyncTasks.Rejected<void>('Shouldn\'t have worked');
+                                    }, () => {
+                                        // Expected to fail, so chain from failure to success
+                                        return undefined;
+                                    });
+
+                                    return SyncTasks.all([p1, p2, p3]).then(() => {
+                                        return prov.close();
+                                    });
+                                });
+                            });
+                        });
                     }
                 });
             }