Skip to content

Commit 1581827

Browse files
berickson1berickson1
authored
Remove a bunch of null assertions by cleaning up _.attempt calls (#65)
1 parent 5516b3c commit 1581827

4 files changed

Lines changed: 92 additions & 113 deletions

File tree

‎src/FullTextSearchHelpers.ts‎

Lines changed: 6 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -61,26 +61,24 @@ export abstract class DbIndexFTSFromRangeQueries implements NoSqlProvider.DbInde
6161
return this.getRange(term, upperEnd, false, true, false, limit);
6262
});
6363
return SyncTasks.all(promises).then(results => {
64-
let uniquers: _.Dictionary<ItemType>[];
65-
66-
const err = _.attempt(() => {
67-
uniquers = _.map(results, resultSet => _.keyBy(resultSet, item =>
64+
const uniquers = _.attempt(() => {
65+
return _.map(results, resultSet => _.keyBy(resultSet, item =>
6866
NoSqlProviderUtils.getSerializedKeyForKeypath(item, this._primaryKeyPath)));
6967
});
70-
if (err) {
71-
return SyncTasks.Rejected(err);
68+
if (_.isError(uniquers)) {
69+
return SyncTasks.Rejected(uniquers);
7270
}
7371

7472
if (resolution === NoSqlProvider.FullTextTermResolution.Or) {
75-
const data = _.values(_.assign({}, ...uniquers!!!));
73+
const data = _.values(_.assign({}, ...uniquers));
7674
if (limit) {
7775
return _.take(data, limit);
7876
}
7977
return data;
8078
}
8179

8280
if (resolution === NoSqlProvider.FullTextTermResolution.And) {
83-
const [first, ...others] = uniquers!!!;
81+
const [first, ...others] = uniquers;
8482
const dic = _.pickBy(first, (value, key) => _.every(others, set => key in set)) as _.Dictionary<ItemType>;
8583
const data = _.values(dic);
8684
if (limit) {

‎src/InMemoryProvider.ts‎

Lines changed: 31 additions & 37 deletions
Original file line numberDiff line numberDiff line change
@@ -167,31 +167,29 @@ class InMemoryStore implements NoSqlProvider.DbStore {
167167
return SyncTasks.Rejected('InMemoryTransaction already closed');
168168
}
169169

170-
let joinedKey: string;
171-
const err = _.attempt(() => {
172-
joinedKey = NoSqlProviderUtils.serializeKeyToString(key, this._storeSchema.primaryKeyPath);
170+
const joinedKey = _.attempt(() => {
171+
return NoSqlProviderUtils.serializeKeyToString(key, this._storeSchema.primaryKeyPath);
173172
});
174-
if (err) {
175-
return SyncTasks.Rejected(err);
173+
if (_.isError(joinedKey)) {
174+
return SyncTasks.Rejected(joinedKey);
176175
}
177176

178-
return SyncTasks.Resolved(this._mergedData[joinedKey!!!]);
177+
return SyncTasks.Resolved(this._mergedData[joinedKey]);
179178
}
180179

181180
getMultiple(keyOrKeys: KeyType|KeyType[]): SyncTasks.Promise<ItemType[]> {
182181
if (!this._trans.internal_isOpen()) {
183182
return SyncTasks.Rejected('InMemoryTransaction already closed');
184183
}
185184

186-
let joinedKeys: string[];
187-
const err = _.attempt(() => {
188-
joinedKeys = NoSqlProviderUtils.formListOfSerializedKeys(keyOrKeys, this._storeSchema.primaryKeyPath);
185+
const joinedKeys = _.attempt(() => {
186+
return NoSqlProviderUtils.formListOfSerializedKeys(keyOrKeys, this._storeSchema.primaryKeyPath);
189187
});
190-
if (err) {
191-
return SyncTasks.Rejected(err);
188+
if (_.isError(joinedKeys)) {
189+
return SyncTasks.Rejected(joinedKeys);
192190
}
193191

194-
return SyncTasks.Resolved(_.compact(_.map(joinedKeys!!!, key => this._mergedData[key])));
192+
return SyncTasks.Resolved(_.compact(_.map(joinedKeys, key => this._mergedData[key])));
195193
}
196194

197195
put(itemOrItems: ItemType|ItemType[]): SyncTasks.Promise<void> {
@@ -219,15 +217,14 @@ class InMemoryStore implements NoSqlProvider.DbStore {
219217
}
220218
this._checkDataClone();
221219

222-
let joinedKeys: string[];
223-
const err = _.attempt(() => {
224-
joinedKeys = NoSqlProviderUtils.formListOfSerializedKeys(keyOrKeys, this._storeSchema.primaryKeyPath);
220+
const joinedKeys = _.attempt(() => {
221+
return NoSqlProviderUtils.formListOfSerializedKeys(keyOrKeys, this._storeSchema.primaryKeyPath);
225222
});
226-
if (err) {
227-
return SyncTasks.Rejected<void>(err);
223+
if (_.isError(joinedKeys)) {
224+
return SyncTasks.Rejected(joinedKeys);
228225
}
229226

230-
_.each(joinedKeys!!!, key => {
227+
_.each(joinedKeys, key => {
231228
this._pendingCommitDataChanges!!![key] = undefined;
232229
delete this._mergedData[key];
233230
});
@@ -311,16 +308,15 @@ class InMemoryIndex extends FullTextSearchHelpers.DbIndexFTSFromRangeQueries {
311308
return SyncTasks.Rejected('InMemoryTransaction already closed');
312309
}
313310

314-
let data: _.Dictionary<ItemType[]>|_.Dictionary<ItemType>;
315-
const err = _.attempt(() => {
316-
data = this._calcChunkedData();
311+
const data = _.attempt(() => {
312+
return this._calcChunkedData();
317313
});
318-
if (err) {
319-
return SyncTasks.Rejected(err);
314+
if (_.isError(data)) {
315+
return SyncTasks.Rejected(data);
320316
}
321317

322-
const sortedKeys = _.keys(data!!!).sort();
323-
return this._returnResultsFromKeys(data!!!, sortedKeys, reverse, limit, offset);
318+
const sortedKeys = _.keys(data).sort();
319+
return this._returnResultsFromKeys(data, sortedKeys, reverse, limit, offset);
324320
}
325321

326322
getOnly(key: KeyType, reverse?: boolean, limit?: number, offset?: number): SyncTasks.Promise<ItemType[]> {
@@ -377,14 +373,13 @@ class InMemoryIndex extends FullTextSearchHelpers.DbIndexFTSFromRangeQueries {
377373
if (!this._trans.internal_isOpen()) {
378374
return SyncTasks.Rejected('InMemoryTransaction already closed');
379375
}
380-
let data: _.Dictionary<ItemType[]>|_.Dictionary<ItemType>;
381-
const err = _.attempt(() => {
382-
data = this._calcChunkedData();
376+
const data = _.attempt(() => {
377+
return this._calcChunkedData();
383378
});
384-
if (err) {
385-
return SyncTasks.Rejected(err);
379+
if (_.isError(data)) {
380+
return SyncTasks.Rejected(data);
386381
}
387-
return SyncTasks.Resolved(_.keys(data!!!).length);
382+
return SyncTasks.Resolved(_.keys(data).length);
388383
}
389384

390385
countOnly(key: KeyType): SyncTasks.Promise<number> {
@@ -397,15 +392,14 @@ class InMemoryIndex extends FullTextSearchHelpers.DbIndexFTSFromRangeQueries {
397392
return SyncTasks.Rejected('InMemoryTransaction already closed');
398393
}
399394

400-
let keys: string[];
401-
const err = _.attempt(() => {
395+
const keys = _.attempt(() => {
402396
const data = this._calcChunkedData();
403-
keys = this._getKeysForRange(data, keyLowRange, keyHighRange, lowRangeExclusive, highRangeExclusive);
397+
return this._getKeysForRange(data, keyLowRange, keyHighRange, lowRangeExclusive, highRangeExclusive);
404398
});
405-
if (err) {
406-
return SyncTasks.Rejected(err);
399+
if (_.isError(keys)) {
400+
return SyncTasks.Rejected(keys);
407401
}
408402

409-
return SyncTasks.Resolved(keys!!!.length);
403+
return SyncTasks.Resolved(keys.length);
410404
}
411405
}

‎src/IndexedDbProvider.ts‎

Lines changed: 46 additions & 56 deletions
Original file line numberDiff line numberDiff line change
@@ -293,22 +293,20 @@ export class IndexedDbProvider extends NoSqlProvider.DbProvider {
293293
}
294294

295295
protected _deleteDatabaseInternal(): SyncTasks.Promise<void> {
296-
let trans: IDBOpenDBRequest;
297-
298-
const err = _.attempt(() => {
299-
trans = this._dbFactory.deleteDatabase(this._dbName!!!);
296+
const trans = _.attempt(() => {
297+
return this._dbFactory.deleteDatabase(this._dbName!!!);
300298
});
301299

302-
if (err) {
303-
return SyncTasks.Rejected(err);
300+
if (_.isError(trans)) {
301+
return SyncTasks.Rejected(trans);
304302
}
305303

306304
const deferred = SyncTasks.Defer<void>();
307305

308-
trans!!!.onsuccess = () => {
306+
trans.onsuccess = () => {
309307
deferred.resolve(void 0);
310308
};
311-
trans!!!.onerror = (ev) => {
309+
trans.onerror = (ev) => {
312310
deferred.reject(ev);
313311
};
314312

@@ -348,15 +346,14 @@ export class IndexedDbProvider extends NoSqlProvider.DbProvider {
348346
}
349347

350348
return this._lockHelper!!!.openTransaction(storeNames, writeNeeded).then(transToken => {
351-
let trans: IDBTransaction;
352-
const err = _.attempt(() => {
353-
trans = this._db!!!.transaction(intStoreNames, writeNeeded ? 'readwrite' : 'readonly');
349+
const trans = _.attempt(() => {
350+
return this._db!!!.transaction(intStoreNames, writeNeeded ? 'readwrite' : 'readonly');
354351
});
355-
if (err) {
356-
return SyncTasks.Rejected(err);
352+
if (_.isError(trans)) {
353+
return SyncTasks.Rejected(trans);
357354
}
358355

359-
return new IndexedDbTransaction(trans!!!, this._lockHelper, transToken, this._schema!!!, this._fakeComplicatedKeys);
356+
return new IndexedDbTransaction(trans, this._lockHelper, transToken, this._schema!!!, this._fakeComplicatedKeys);
360357
});
361358
}
362359
}
@@ -483,20 +480,20 @@ class IndexedDbStore implements NoSqlProvider.DbStore {
483480
}
484481

485482
getMultiple(keyOrKeys: KeyType|KeyType[]): SyncTasks.Promise<ItemType[]> {
486-
let keys: any[];
487-
const err = _.attempt(() => {
488-
keys = NoSqlProviderUtils.formListOfKeys(keyOrKeys, this._schema.primaryKeyPath);
483+
const keys = _.attempt(() => {
484+
const keys = NoSqlProviderUtils.formListOfKeys(keyOrKeys, this._schema.primaryKeyPath);
489485

490486
if (this._fakeComplicatedKeys && NoSqlProviderUtils.isCompoundKeyPath(this._schema.primaryKeyPath)) {
491-
keys = _.map(keys, key => NoSqlProviderUtils.serializeKeyToString(key, this._schema.primaryKeyPath));
487+
return _.map(keys, key => NoSqlProviderUtils.serializeKeyToString(key, this._schema.primaryKeyPath));
492488
}
489+
return keys;
493490
});
494-
if (err) {
495-
return SyncTasks.Rejected(err);
491+
if (_.isError(keys)) {
492+
return SyncTasks.Rejected(keys);
496493
}
497494

498495
// There isn't a more optimized way to do this with indexeddb, have to get the results one by one
499-
return SyncTasks.all(_.map(keys!!!, key =>
496+
return SyncTasks.all(_.map(keys, key =>
500497
IndexedDbProvider.WrapRequest(this._store.get(key)).then(val => removeFullTextMetadataAndReturn(this._schema, val))))
501498
.then(_.compact);
502499
}
@@ -612,44 +609,41 @@ class IndexedDbStore implements NoSqlProvider.DbStore {
612609
}
613610

614611
remove(keyOrKeys: KeyType|KeyType[]): SyncTasks.Promise<void> {
615-
let keys: any[];
616-
const err = _.attempt(() => {
617-
keys = NoSqlProviderUtils.formListOfKeys(keyOrKeys, this._schema.primaryKeyPath);
612+
const keys = _.attempt(() => {
613+
const keys = NoSqlProviderUtils.formListOfKeys(keyOrKeys, this._schema.primaryKeyPath);
618614

619615
if (this._fakeComplicatedKeys && NoSqlProviderUtils.isCompoundKeyPath(this._schema.primaryKeyPath)) {
620-
keys = _.map(keys, key => NoSqlProviderUtils.serializeKeyToString(key, this._schema.primaryKeyPath));
616+
return _.map(keys, key => NoSqlProviderUtils.serializeKeyToString(key, this._schema.primaryKeyPath));
621617
}
618+
return keys;
622619
});
623-
if (err) {
624-
return SyncTasks.Rejected<void>(err);
620+
if (_.isError(keys)) {
621+
return SyncTasks.Rejected<void>(keys);
625622
}
626623

627-
return SyncTasks.all(_.map(keys!!!, key => {
624+
return SyncTasks.all(_.map(keys, key => {
628625
if (this._fakeComplicatedKeys && _.some(this._schema.indexes, index => index.multiEntry || index.fullText)) {
629626
// If we're faking keys and there's any multientry indexes, we have to do the way more complicated version...
630627
return IndexedDbProvider.WrapRequest<any>(this._store.get(key)).then(item => {
631628
if (item) {
632629
// Go through each multiEntry index and nuke the referenced items from the sub-stores
633630
let promises = _.map(_.filter(this._schema.indexes, index => !!index.multiEntry), index => {
634631
let indexStore = _.find(this._indexStores, store => store.name === this._schema.name + '_' + index.name)!!!;
635-
636-
let refKey: KeyType;
637-
const err = _.attempt(() => {
638-
632+
const refKey = _.attempt(() => {
639633
// We need to reference the PK of the actual row we're using here, so calculate the actual PK -- if it's
640634
// compound, we're already faking complicated keys, so we know to serialize it to a string. If not, use the
641635
// raw value.
642636
const tempRefKey = NoSqlProviderUtils.getKeyForKeypath(item, this._schema.primaryKeyPath)!!!;
643-
refKey = _.isArray(this._schema.primaryKeyPath) ?
637+
return _.isArray(this._schema.primaryKeyPath) ?
644638
NoSqlProviderUtils.serializeKeyToString(tempRefKey, this._schema.primaryKeyPath) :
645639
tempRefKey;
646640
});
647-
if (err) {
648-
return SyncTasks.Rejected<void>(err);
641+
if (_.isError(refKey)) {
642+
return SyncTasks.Rejected<void>(refKey);
649643
}
650644

651645
// First clear out the old values from the index store for the refkey
652-
const cursorReq = indexStore.index('refkey').openCursor(IDBKeyRange.only(refKey!!!));
646+
const cursorReq = indexStore.index('refkey').openCursor(IDBKeyRange.only(refKey));
653647
return IndexedDbIndex.iterateOverCursorRequest(cursorReq, cursor => {
654648
cursor['delete']();
655649
});
@@ -735,12 +729,11 @@ class IndexedDbIndex extends FullTextSearchHelpers.DbIndexFTSFromRangeQueries {
735729
}
736730

737731
getOnly(key: KeyType, reverse?: boolean, limit?: number, offset?: number): SyncTasks.Promise<ItemType[]> {
738-
let keyRange: any;
739-
const err = _.attempt(() => {
740-
keyRange = this._getKeyRangeForOnly(key);
732+
const keyRange = _.attempt(() => {
733+
return this._getKeyRangeForOnly(key);
741734
});
742-
if (err) {
743-
return SyncTasks.Rejected(err);
735+
if (_.isError(keyRange)) {
736+
return SyncTasks.Rejected(keyRange);
744737
}
745738

746739
const req = this._store.openCursor(keyRange, reverse ? 'prev' : 'next');
@@ -757,12 +750,11 @@ class IndexedDbIndex extends FullTextSearchHelpers.DbIndexFTSFromRangeQueries {
757750

758751
getRange(keyLowRange: KeyType, keyHighRange: KeyType, lowRangeExclusive?: boolean, highRangeExclusive?: boolean,
759752
reverse?: boolean, limit?: number, offset?: number): SyncTasks.Promise<ItemType[]> {
760-
let keyRange: any;
761-
const err = _.attempt(() => {
762-
keyRange = this._getKeyRangeForRange(keyLowRange, keyHighRange, lowRangeExclusive, highRangeExclusive);
753+
const keyRange = _.attempt(() => {
754+
return this._getKeyRangeForRange(keyLowRange, keyHighRange, lowRangeExclusive, highRangeExclusive);
763755
});
764-
if (err) {
765-
return SyncTasks.Rejected(err);
756+
if (_.isError(keyRange)) {
757+
return SyncTasks.Rejected(keyRange);
766758
}
767759

768760
const req = this._store.openCursor(keyRange, reverse ? 'prev' : 'next');
@@ -788,12 +780,11 @@ class IndexedDbIndex extends FullTextSearchHelpers.DbIndexFTSFromRangeQueries {
788780
}
789781

790782
countOnly(key: KeyType): SyncTasks.Promise<number> {
791-
let keyRange: any;
792-
const err = _.attempt(() => {
793-
keyRange = this._getKeyRangeForOnly(key);
783+
const keyRange = _.attempt(() => {
784+
return this._getKeyRangeForOnly(key);
794785
});
795-
if (err) {
796-
return SyncTasks.Rejected(err);
786+
if (_.isError(keyRange)) {
787+
return SyncTasks.Rejected(keyRange);
797788
}
798789

799790
const req = this._store.count(keyRange);
@@ -802,12 +793,11 @@ class IndexedDbIndex extends FullTextSearchHelpers.DbIndexFTSFromRangeQueries {
802793

803794
countRange(keyLowRange: KeyType, keyHighRange: KeyType, lowRangeExclusive?: boolean, highRangeExclusive?: boolean)
804795
: SyncTasks.Promise<number> {
805-
let keyRange: any;
806-
const err = _.attempt(() => {
807-
keyRange = this._getKeyRangeForRange(keyLowRange, keyHighRange, lowRangeExclusive, highRangeExclusive);
796+
let keyRange = _.attempt(() => {
797+
return this._getKeyRangeForRange(keyLowRange, keyHighRange, lowRangeExclusive, highRangeExclusive);
808798
});
809-
if (err) {
810-
return SyncTasks.Rejected(err);
799+
if (_.isError(keyRange)) {
800+
return SyncTasks.Rejected(keyRange);
811801
}
812802

813803
const req = this._store.count(keyRange);

0 commit comments

Comments
 (0)