@expo/entity-database-adapter-knex 0.32.0 → 0.34.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/build/__integration-tests__/PostgresEntityIntegration-test.js +110 -80
- package/build/__integration-tests__/PostgresEntityIntegration-test.js.map +1 -1
- package/build/__integration-tests__/PostgresEntityQueryContextProvider-test.js +15 -5
- package/build/__integration-tests__/PostgresEntityQueryContextProvider-test.js.map +1 -1
- package/build/__integration-tests__/PostgresInvalidSetup-test.js +28 -9
- package/build/__integration-tests__/PostgresInvalidSetup-test.js.map +1 -1
- package/build/__integration-tests__/errors-test.js +15 -13
- package/build/__integration-tests__/errors-test.js.map +1 -1
- package/package.json +3 -3
- package/src/__integration-tests__/PostgresEntityIntegration-test.ts +364 -80
- package/src/__integration-tests__/PostgresEntityQueryContextProvider-test.ts +30 -5
- package/src/__integration-tests__/PostgresInvalidSetup-test.ts +57 -11
- package/src/__integration-tests__/errors-test.ts +56 -15
|
@@ -42,16 +42,34 @@ describe('postgres entity integration', () => {
|
|
|
42
42
|
it('supports parallel partial updates', async () => {
|
|
43
43
|
const vc = new ViewerContext(createKnexIntegrationTestEntityCompanionProvider(knexInstance));
|
|
44
44
|
const entity = await enforceAsyncResult(
|
|
45
|
-
PostgresTestEntity.creator(
|
|
45
|
+
PostgresTestEntity.creator(
|
|
46
|
+
vc,
|
|
47
|
+
vc.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
|
|
48
|
+
)
|
|
49
|
+
.setField('name', 'hello')
|
|
50
|
+
.createAsync()
|
|
46
51
|
);
|
|
47
52
|
|
|
48
53
|
// update two different fields at the same time (from the same entity)
|
|
49
54
|
await Promise.all([
|
|
50
|
-
PostgresTestEntity.updater(
|
|
51
|
-
|
|
55
|
+
PostgresTestEntity.updater(
|
|
56
|
+
entity,
|
|
57
|
+
vc.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
|
|
58
|
+
)
|
|
59
|
+
.setField('hasACat', true)
|
|
60
|
+
.updateAsync(),
|
|
61
|
+
PostgresTestEntity.updater(
|
|
62
|
+
entity,
|
|
63
|
+
vc.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
|
|
64
|
+
)
|
|
65
|
+
.setField('hasADog', false)
|
|
66
|
+
.updateAsync(),
|
|
52
67
|
]);
|
|
53
68
|
|
|
54
|
-
const loadedEntity = await PostgresTestEntity.loader(
|
|
69
|
+
const loadedEntity = await PostgresTestEntity.loader(
|
|
70
|
+
vc,
|
|
71
|
+
vc.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
|
|
72
|
+
)
|
|
55
73
|
.enforcing()
|
|
56
74
|
.loadByIDAsync(entity.getID());
|
|
57
75
|
|
|
@@ -62,24 +80,49 @@ describe('postgres entity integration', () => {
|
|
|
62
80
|
describe('empty creates and updates', () => {
|
|
63
81
|
it('allows empty create', async () => {
|
|
64
82
|
const vc = new ViewerContext(createKnexIntegrationTestEntityCompanionProvider(knexInstance));
|
|
65
|
-
const entity = await enforceAsyncResult(
|
|
83
|
+
const entity = await enforceAsyncResult(
|
|
84
|
+
PostgresTestEntity.creator(
|
|
85
|
+
vc,
|
|
86
|
+
vc.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
|
|
87
|
+
).createAsync()
|
|
88
|
+
);
|
|
66
89
|
expect(entity.getID()).toBeTruthy();
|
|
67
90
|
});
|
|
68
91
|
|
|
69
92
|
it('throws knex error upon empty update', async () => {
|
|
70
93
|
const vc = new ViewerContext(createKnexIntegrationTestEntityCompanionProvider(knexInstance));
|
|
71
94
|
const entity = await enforceAsyncResult(
|
|
72
|
-
PostgresTestEntity.creator(
|
|
95
|
+
PostgresTestEntity.creator(
|
|
96
|
+
vc,
|
|
97
|
+
vc.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
|
|
98
|
+
)
|
|
99
|
+
.setField('name', 'hello')
|
|
100
|
+
.createAsync()
|
|
73
101
|
);
|
|
74
|
-
await expect(
|
|
102
|
+
await expect(
|
|
103
|
+
PostgresTestEntity.updater(
|
|
104
|
+
entity,
|
|
105
|
+
vc.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
|
|
106
|
+
).updateAsync()
|
|
107
|
+
).rejects.toThrow();
|
|
75
108
|
});
|
|
76
109
|
|
|
77
110
|
it('throws error upon empty update for stub database adapter to match behavior', async () => {
|
|
78
111
|
const vc = new ViewerContext(createUnitTestEntityCompanionProvider());
|
|
79
112
|
const entity = await enforceAsyncResult(
|
|
80
|
-
PostgresTestEntity.creator(
|
|
113
|
+
PostgresTestEntity.creator(
|
|
114
|
+
vc,
|
|
115
|
+
vc.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
|
|
116
|
+
)
|
|
117
|
+
.setField('name', 'hello')
|
|
118
|
+
.createAsync()
|
|
81
119
|
);
|
|
82
|
-
await expect(
|
|
120
|
+
await expect(
|
|
121
|
+
PostgresTestEntity.updater(
|
|
122
|
+
entity,
|
|
123
|
+
vc.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
|
|
124
|
+
).updateAsync()
|
|
125
|
+
).rejects.toThrow();
|
|
83
126
|
});
|
|
84
127
|
});
|
|
85
128
|
|
|
@@ -88,10 +131,20 @@ describe('postgres entity integration', () => {
|
|
|
88
131
|
|
|
89
132
|
// put one in the DB
|
|
90
133
|
const firstEntity = await enforceAsyncResult(
|
|
91
|
-
PostgresTestEntity.creator(
|
|
134
|
+
PostgresTestEntity.creator(
|
|
135
|
+
vc1,
|
|
136
|
+
vc1.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
|
|
137
|
+
)
|
|
138
|
+
.setField('name', 'hello')
|
|
139
|
+
.createAsync()
|
|
92
140
|
);
|
|
93
141
|
|
|
94
|
-
await enforceAsyncResult(
|
|
142
|
+
await enforceAsyncResult(
|
|
143
|
+
PostgresTestEntity.loader(
|
|
144
|
+
vc1,
|
|
145
|
+
vc1.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
|
|
146
|
+
).loadByIDAsync(firstEntity.getID())
|
|
147
|
+
);
|
|
95
148
|
|
|
96
149
|
const errorToThrow = new Error('Intentional error');
|
|
97
150
|
|
|
@@ -107,7 +160,10 @@ describe('postgres entity integration', () => {
|
|
|
107
160
|
).rejects.toEqual(errorToThrow);
|
|
108
161
|
|
|
109
162
|
const entities = await enforceResultsAsync(
|
|
110
|
-
PostgresTestEntity.loader(
|
|
163
|
+
PostgresTestEntity.loader(
|
|
164
|
+
vc1,
|
|
165
|
+
vc1.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
|
|
166
|
+
).loadManyByFieldEqualingAsync('name', 'hello')
|
|
111
167
|
);
|
|
112
168
|
expect(entities).toHaveLength(1);
|
|
113
169
|
});
|
|
@@ -116,7 +172,12 @@ describe('postgres entity integration', () => {
|
|
|
116
172
|
const vc1 = new ViewerContext(createKnexIntegrationTestEntityCompanionProvider(knexInstance));
|
|
117
173
|
|
|
118
174
|
const firstEntity = await enforceAsyncResult(
|
|
119
|
-
PostgresTestEntity.creator(
|
|
175
|
+
PostgresTestEntity.creator(
|
|
176
|
+
vc1,
|
|
177
|
+
vc1.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
|
|
178
|
+
)
|
|
179
|
+
.setField('name', 'hello')
|
|
180
|
+
.createAsync()
|
|
120
181
|
);
|
|
121
182
|
|
|
122
183
|
const loadAndUpdateAsync = async (newName: string): Promise<{ error?: Error }> => {
|
|
@@ -155,7 +216,10 @@ describe('postgres entity integration', () => {
|
|
|
155
216
|
const vc1 = new ViewerContext(createKnexIntegrationTestEntityCompanionProvider(knexInstance));
|
|
156
217
|
|
|
157
218
|
const entity = await enforceAsyncResult(
|
|
158
|
-
PostgresTestEntity.creator(
|
|
219
|
+
PostgresTestEntity.creator(
|
|
220
|
+
vc1,
|
|
221
|
+
vc1.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
|
|
222
|
+
)
|
|
159
223
|
.setField('stringArray', ['hello', 'world'])
|
|
160
224
|
.setField('jsonArrayField', ['hello', 'world'])
|
|
161
225
|
.createAsync()
|
|
@@ -169,7 +233,10 @@ describe('postgres entity integration', () => {
|
|
|
169
233
|
const vc1 = new ViewerContext(createKnexIntegrationTestEntityCompanionProvider(knexInstance));
|
|
170
234
|
|
|
171
235
|
const entity = await enforceAsyncResult(
|
|
172
|
-
PostgresTestEntity.creator(
|
|
236
|
+
PostgresTestEntity.creator(
|
|
237
|
+
vc1,
|
|
238
|
+
vc1.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
|
|
239
|
+
)
|
|
173
240
|
.setField('jsonObjectField', { hello: 'world' })
|
|
174
241
|
.createAsync()
|
|
175
242
|
);
|
|
@@ -181,12 +248,18 @@ describe('postgres entity integration', () => {
|
|
|
181
248
|
const vc1 = new ViewerContext(createKnexIntegrationTestEntityCompanionProvider(knexInstance));
|
|
182
249
|
|
|
183
250
|
const entity1 = await enforceAsyncResult(
|
|
184
|
-
PostgresTestEntity.creator(
|
|
251
|
+
PostgresTestEntity.creator(
|
|
252
|
+
vc1,
|
|
253
|
+
vc1.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
|
|
254
|
+
)
|
|
185
255
|
.setField('maybeJsonArrayField', ['hello', 'world'])
|
|
186
256
|
.createAsync()
|
|
187
257
|
);
|
|
188
258
|
const entity2 = await enforceAsyncResult(
|
|
189
|
-
PostgresTestEntity.creator(
|
|
259
|
+
PostgresTestEntity.creator(
|
|
260
|
+
vc1,
|
|
261
|
+
vc1.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
|
|
262
|
+
)
|
|
190
263
|
.setField('maybeJsonArrayField', { hello: 'world' })
|
|
191
264
|
.createAsync()
|
|
192
265
|
);
|
|
@@ -201,17 +274,32 @@ describe('postgres entity integration', () => {
|
|
|
201
274
|
const vc1 = new ViewerContext(createKnexIntegrationTestEntityCompanionProvider(knexInstance));
|
|
202
275
|
|
|
203
276
|
let entity = await enforceAsyncResult(
|
|
204
|
-
PostgresTestEntity.creator(
|
|
277
|
+
PostgresTestEntity.creator(
|
|
278
|
+
vc1,
|
|
279
|
+
vc1.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
|
|
280
|
+
)
|
|
281
|
+
.setField('bigintField', '72057594037928038')
|
|
282
|
+
.createAsync()
|
|
205
283
|
);
|
|
206
284
|
expect(entity.getField('bigintField')).toEqual('72057594037928038');
|
|
207
285
|
|
|
208
286
|
entity = await enforceAsyncResult(
|
|
209
|
-
PostgresTestEntity.updater(
|
|
287
|
+
PostgresTestEntity.updater(
|
|
288
|
+
entity,
|
|
289
|
+
vc1.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
|
|
290
|
+
)
|
|
291
|
+
.setField('bigintField', '10')
|
|
292
|
+
.updateAsync()
|
|
210
293
|
);
|
|
211
294
|
expect(entity.getField('bigintField')).toEqual('10');
|
|
212
295
|
|
|
213
296
|
entity = await enforceAsyncResult(
|
|
214
|
-
PostgresTestEntity.updater(
|
|
297
|
+
PostgresTestEntity.updater(
|
|
298
|
+
entity,
|
|
299
|
+
vc1.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
|
|
300
|
+
)
|
|
301
|
+
.setField('bigintField', '-10')
|
|
302
|
+
.updateAsync()
|
|
215
303
|
);
|
|
216
304
|
expect(entity.getField('bigintField')).toEqual('-10');
|
|
217
305
|
});
|
|
@@ -222,7 +310,10 @@ describe('postgres entity integration', () => {
|
|
|
222
310
|
const vc1 = new ViewerContext(createKnexIntegrationTestEntityCompanionProvider(knexInstance));
|
|
223
311
|
|
|
224
312
|
await enforceAsyncResult(
|
|
225
|
-
PostgresTestEntity.creator(
|
|
313
|
+
PostgresTestEntity.creator(
|
|
314
|
+
vc1,
|
|
315
|
+
vc1.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
|
|
316
|
+
)
|
|
226
317
|
.setField('name', 'hello')
|
|
227
318
|
.setField('hasACat', false)
|
|
228
319
|
.setField('hasADog', true)
|
|
@@ -230,7 +321,10 @@ describe('postgres entity integration', () => {
|
|
|
230
321
|
);
|
|
231
322
|
|
|
232
323
|
await enforceAsyncResult(
|
|
233
|
-
PostgresTestEntity.creator(
|
|
324
|
+
PostgresTestEntity.creator(
|
|
325
|
+
vc1,
|
|
326
|
+
vc1.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
|
|
327
|
+
)
|
|
234
328
|
.setField('name', 'world')
|
|
235
329
|
.setField('hasACat', false)
|
|
236
330
|
.setField('hasADog', true)
|
|
@@ -238,14 +332,20 @@ describe('postgres entity integration', () => {
|
|
|
238
332
|
);
|
|
239
333
|
|
|
240
334
|
await enforceAsyncResult(
|
|
241
|
-
PostgresTestEntity.creator(
|
|
335
|
+
PostgresTestEntity.creator(
|
|
336
|
+
vc1,
|
|
337
|
+
vc1.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
|
|
338
|
+
)
|
|
242
339
|
.setField('name', 'wat')
|
|
243
340
|
.setField('hasACat', false)
|
|
244
341
|
.setField('hasADog', false)
|
|
245
342
|
.createAsync()
|
|
246
343
|
);
|
|
247
344
|
|
|
248
|
-
const results = await PostgresTestEntity.loader(
|
|
345
|
+
const results = await PostgresTestEntity.loader(
|
|
346
|
+
vc1,
|
|
347
|
+
vc1.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
|
|
348
|
+
)
|
|
249
349
|
.enforcing()
|
|
250
350
|
.loadManyByFieldEqualityConjunctionAsync([
|
|
251
351
|
{
|
|
@@ -260,7 +360,10 @@ describe('postgres entity integration', () => {
|
|
|
260
360
|
|
|
261
361
|
expect(results).toHaveLength(2);
|
|
262
362
|
|
|
263
|
-
const results2 = await PostgresTestEntity.loader(
|
|
363
|
+
const results2 = await PostgresTestEntity.loader(
|
|
364
|
+
vc1,
|
|
365
|
+
vc1.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
|
|
366
|
+
)
|
|
264
367
|
.enforcing()
|
|
265
368
|
.loadManyByFieldEqualityConjunctionAsync([
|
|
266
369
|
{ fieldName: 'hasADog', fieldValues: [true, false] },
|
|
@@ -271,13 +374,37 @@ describe('postgres entity integration', () => {
|
|
|
271
374
|
it('supports query modifiers', async () => {
|
|
272
375
|
const vc1 = new ViewerContext(createKnexIntegrationTestEntityCompanionProvider(knexInstance));
|
|
273
376
|
|
|
274
|
-
await enforceAsyncResult(
|
|
377
|
+
await enforceAsyncResult(
|
|
378
|
+
PostgresTestEntity.creator(
|
|
379
|
+
vc1,
|
|
380
|
+
vc1.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
|
|
381
|
+
)
|
|
382
|
+
.setField('name', 'a')
|
|
383
|
+
.createAsync()
|
|
384
|
+
);
|
|
275
385
|
|
|
276
|
-
await enforceAsyncResult(
|
|
386
|
+
await enforceAsyncResult(
|
|
387
|
+
PostgresTestEntity.creator(
|
|
388
|
+
vc1,
|
|
389
|
+
vc1.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
|
|
390
|
+
)
|
|
391
|
+
.setField('name', 'b')
|
|
392
|
+
.createAsync()
|
|
393
|
+
);
|
|
277
394
|
|
|
278
|
-
await enforceAsyncResult(
|
|
395
|
+
await enforceAsyncResult(
|
|
396
|
+
PostgresTestEntity.creator(
|
|
397
|
+
vc1,
|
|
398
|
+
vc1.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
|
|
399
|
+
)
|
|
400
|
+
.setField('name', 'c')
|
|
401
|
+
.createAsync()
|
|
402
|
+
);
|
|
279
403
|
|
|
280
|
-
const results = await PostgresTestEntity.loader(
|
|
404
|
+
const results = await PostgresTestEntity.loader(
|
|
405
|
+
vc1,
|
|
406
|
+
vc1.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
|
|
407
|
+
)
|
|
281
408
|
.enforcing()
|
|
282
409
|
.loadManyByFieldEqualityConjunctionAsync([], {
|
|
283
410
|
limit: 2,
|
|
@@ -296,37 +423,55 @@ describe('postgres entity integration', () => {
|
|
|
296
423
|
it('supports null field values', async () => {
|
|
297
424
|
const vc1 = new ViewerContext(createKnexIntegrationTestEntityCompanionProvider(knexInstance));
|
|
298
425
|
await enforceAsyncResult(
|
|
299
|
-
PostgresTestEntity.creator(
|
|
426
|
+
PostgresTestEntity.creator(
|
|
427
|
+
vc1,
|
|
428
|
+
vc1.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
|
|
429
|
+
)
|
|
300
430
|
.setField('name', 'a')
|
|
301
431
|
.setField('hasADog', true)
|
|
302
432
|
.createAsync()
|
|
303
433
|
);
|
|
304
434
|
await enforceAsyncResult(
|
|
305
|
-
PostgresTestEntity.creator(
|
|
435
|
+
PostgresTestEntity.creator(
|
|
436
|
+
vc1,
|
|
437
|
+
vc1.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
|
|
438
|
+
)
|
|
306
439
|
.setField('name', 'b')
|
|
307
440
|
.setField('hasADog', true)
|
|
308
441
|
.createAsync()
|
|
309
442
|
);
|
|
310
443
|
await enforceAsyncResult(
|
|
311
|
-
PostgresTestEntity.creator(
|
|
444
|
+
PostgresTestEntity.creator(
|
|
445
|
+
vc1,
|
|
446
|
+
vc1.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
|
|
447
|
+
)
|
|
312
448
|
.setField('name', null)
|
|
313
449
|
.setField('hasADog', true)
|
|
314
450
|
.createAsync()
|
|
315
451
|
);
|
|
316
452
|
await enforceAsyncResult(
|
|
317
|
-
PostgresTestEntity.creator(
|
|
453
|
+
PostgresTestEntity.creator(
|
|
454
|
+
vc1,
|
|
455
|
+
vc1.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
|
|
456
|
+
)
|
|
318
457
|
.setField('name', null)
|
|
319
458
|
.setField('hasADog', false)
|
|
320
459
|
.createAsync()
|
|
321
460
|
);
|
|
322
461
|
|
|
323
|
-
const results = await PostgresTestEntity.loader(
|
|
462
|
+
const results = await PostgresTestEntity.loader(
|
|
463
|
+
vc1,
|
|
464
|
+
vc1.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
|
|
465
|
+
)
|
|
324
466
|
.enforcing()
|
|
325
467
|
.loadManyByFieldEqualityConjunctionAsync([{ fieldName: 'name', fieldValue: null }]);
|
|
326
468
|
expect(results).toHaveLength(2);
|
|
327
469
|
expect(results[0]!.getField('name')).toBeNull();
|
|
328
470
|
|
|
329
|
-
const results2 = await PostgresTestEntity.loader(
|
|
471
|
+
const results2 = await PostgresTestEntity.loader(
|
|
472
|
+
vc1,
|
|
473
|
+
vc1.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
|
|
474
|
+
)
|
|
330
475
|
.enforcing()
|
|
331
476
|
.loadManyByFieldEqualityConjunctionAsync(
|
|
332
477
|
[
|
|
@@ -351,14 +496,20 @@ describe('postgres entity integration', () => {
|
|
|
351
496
|
it('loads by raw where clause', async () => {
|
|
352
497
|
const vc1 = new ViewerContext(createKnexIntegrationTestEntityCompanionProvider(knexInstance));
|
|
353
498
|
await enforceAsyncResult(
|
|
354
|
-
PostgresTestEntity.creator(
|
|
499
|
+
PostgresTestEntity.creator(
|
|
500
|
+
vc1,
|
|
501
|
+
vc1.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
|
|
502
|
+
)
|
|
355
503
|
.setField('name', 'hello')
|
|
356
504
|
.setField('hasACat', false)
|
|
357
505
|
.setField('hasADog', true)
|
|
358
506
|
.createAsync()
|
|
359
507
|
);
|
|
360
508
|
|
|
361
|
-
const results = await PostgresTestEntity.loader(
|
|
509
|
+
const results = await PostgresTestEntity.loader(
|
|
510
|
+
vc1,
|
|
511
|
+
vc1.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
|
|
512
|
+
)
|
|
362
513
|
.enforcing()
|
|
363
514
|
.loadManyByRawWhereClauseAsync('name = ?', ['hello']);
|
|
364
515
|
|
|
@@ -368,7 +519,10 @@ describe('postgres entity integration', () => {
|
|
|
368
519
|
it('throws with invalid where clause', async () => {
|
|
369
520
|
const vc1 = new ViewerContext(createKnexIntegrationTestEntityCompanionProvider(knexInstance));
|
|
370
521
|
await enforceAsyncResult(
|
|
371
|
-
PostgresTestEntity.creator(
|
|
522
|
+
PostgresTestEntity.creator(
|
|
523
|
+
vc1,
|
|
524
|
+
vc1.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
|
|
525
|
+
)
|
|
372
526
|
.setField('name', 'hello')
|
|
373
527
|
.setField('hasACat', false)
|
|
374
528
|
.setField('hasADog', true)
|
|
@@ -376,7 +530,10 @@ describe('postgres entity integration', () => {
|
|
|
376
530
|
);
|
|
377
531
|
|
|
378
532
|
await expect(
|
|
379
|
-
PostgresTestEntity.loader(
|
|
533
|
+
PostgresTestEntity.loader(
|
|
534
|
+
vc1,
|
|
535
|
+
vc1.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
|
|
536
|
+
)
|
|
380
537
|
.enforcing()
|
|
381
538
|
.loadManyByRawWhereClauseAsync('invalid_column = ?', ['hello'])
|
|
382
539
|
).rejects.toThrow();
|
|
@@ -386,27 +543,39 @@ describe('postgres entity integration', () => {
|
|
|
386
543
|
const vc1 = new ViewerContext(createKnexIntegrationTestEntityCompanionProvider(knexInstance));
|
|
387
544
|
|
|
388
545
|
await enforceAsyncResult(
|
|
389
|
-
PostgresTestEntity.creator(
|
|
546
|
+
PostgresTestEntity.creator(
|
|
547
|
+
vc1,
|
|
548
|
+
vc1.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
|
|
549
|
+
)
|
|
390
550
|
.setField('name', 'a')
|
|
391
551
|
.setField('hasADog', true)
|
|
392
552
|
.createAsync()
|
|
393
553
|
);
|
|
394
554
|
|
|
395
555
|
await enforceAsyncResult(
|
|
396
|
-
PostgresTestEntity.creator(
|
|
556
|
+
PostgresTestEntity.creator(
|
|
557
|
+
vc1,
|
|
558
|
+
vc1.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
|
|
559
|
+
)
|
|
397
560
|
.setField('name', 'b')
|
|
398
561
|
.setField('hasADog', true)
|
|
399
562
|
.createAsync()
|
|
400
563
|
);
|
|
401
564
|
|
|
402
565
|
await enforceAsyncResult(
|
|
403
|
-
PostgresTestEntity.creator(
|
|
566
|
+
PostgresTestEntity.creator(
|
|
567
|
+
vc1,
|
|
568
|
+
vc1.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
|
|
569
|
+
)
|
|
404
570
|
.setField('name', 'c')
|
|
405
571
|
.setField('hasADog', true)
|
|
406
572
|
.createAsync()
|
|
407
573
|
);
|
|
408
574
|
|
|
409
|
-
const results = await PostgresTestEntity.loader(
|
|
575
|
+
const results = await PostgresTestEntity.loader(
|
|
576
|
+
vc1,
|
|
577
|
+
vc1.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
|
|
578
|
+
)
|
|
410
579
|
.enforcing()
|
|
411
580
|
.loadManyByRawWhereClauseAsync('has_a_dog = ?', [true], {
|
|
412
581
|
limit: 2,
|
|
@@ -422,7 +591,10 @@ describe('postgres entity integration', () => {
|
|
|
422
591
|
expect(results).toHaveLength(2);
|
|
423
592
|
expect(results.map((e) => e.getField('name'))).toEqual(['b', 'c']);
|
|
424
593
|
|
|
425
|
-
const resultsMultipleOrderBy = await PostgresTestEntity.loader(
|
|
594
|
+
const resultsMultipleOrderBy = await PostgresTestEntity.loader(
|
|
595
|
+
vc1,
|
|
596
|
+
vc1.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
|
|
597
|
+
)
|
|
426
598
|
.enforcing()
|
|
427
599
|
.loadManyByRawWhereClauseAsync('has_a_dog = ?', [true], {
|
|
428
600
|
orderBy: [
|
|
@@ -440,7 +612,10 @@ describe('postgres entity integration', () => {
|
|
|
440
612
|
expect(resultsMultipleOrderBy).toHaveLength(3);
|
|
441
613
|
expect(resultsMultipleOrderBy.map((e) => e.getField('name'))).toEqual(['c', 'b', 'a']);
|
|
442
614
|
|
|
443
|
-
const resultsOrderByRaw = await PostgresTestEntity.loader(
|
|
615
|
+
const resultsOrderByRaw = await PostgresTestEntity.loader(
|
|
616
|
+
vc1,
|
|
617
|
+
vc1.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
|
|
618
|
+
)
|
|
444
619
|
.enforcing()
|
|
445
620
|
.loadManyByRawWhereClauseAsync('has_a_dog = ?', [true], {
|
|
446
621
|
orderByRaw: 'has_a_dog ASC, name DESC',
|
|
@@ -459,52 +634,86 @@ describe('postgres entity integration', () => {
|
|
|
459
634
|
);
|
|
460
635
|
|
|
461
636
|
await expect(
|
|
462
|
-
PostgresTriggerTestEntity.creator(
|
|
637
|
+
PostgresTriggerTestEntity.creator(
|
|
638
|
+
vc1,
|
|
639
|
+
vc1.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
|
|
640
|
+
)
|
|
463
641
|
.setField('name', 'beforeCreate')
|
|
464
642
|
.enforceCreateAsync()
|
|
465
643
|
).rejects.toThrowError('name cannot have value beforeCreate');
|
|
466
644
|
await expect(
|
|
467
|
-
PostgresTriggerTestEntity.loader(
|
|
645
|
+
PostgresTriggerTestEntity.loader(
|
|
646
|
+
vc1,
|
|
647
|
+
vc1.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
|
|
648
|
+
)
|
|
468
649
|
.enforcing()
|
|
469
650
|
.loadByFieldEqualingAsync('name', 'beforeCreate')
|
|
470
651
|
).resolves.toBeNull();
|
|
471
652
|
|
|
472
653
|
await expect(
|
|
473
|
-
PostgresTriggerTestEntity.creator(
|
|
654
|
+
PostgresTriggerTestEntity.creator(
|
|
655
|
+
vc1,
|
|
656
|
+
vc1.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
|
|
657
|
+
)
|
|
474
658
|
.setField('name', 'afterCreate')
|
|
475
659
|
.enforceCreateAsync()
|
|
476
660
|
).rejects.toThrowError('name cannot have value afterCreate');
|
|
477
661
|
await expect(
|
|
478
|
-
PostgresTriggerTestEntity.loader(
|
|
662
|
+
PostgresTriggerTestEntity.loader(
|
|
663
|
+
vc1,
|
|
664
|
+
vc1.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
|
|
665
|
+
)
|
|
479
666
|
.enforcing()
|
|
480
667
|
.loadByFieldEqualingAsync('name', 'afterCreate')
|
|
481
668
|
).resolves.toBeNull();
|
|
482
669
|
|
|
483
670
|
await expect(
|
|
484
|
-
PostgresTriggerTestEntity.creator(
|
|
671
|
+
PostgresTriggerTestEntity.creator(
|
|
672
|
+
vc1,
|
|
673
|
+
vc1.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
|
|
674
|
+
)
|
|
675
|
+
.setField('name', 'beforeAll')
|
|
676
|
+
.enforceCreateAsync()
|
|
485
677
|
).rejects.toThrowError('name cannot have value beforeAll');
|
|
486
678
|
await expect(
|
|
487
|
-
PostgresTriggerTestEntity.loader(
|
|
679
|
+
PostgresTriggerTestEntity.loader(
|
|
680
|
+
vc1,
|
|
681
|
+
vc1.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
|
|
682
|
+
)
|
|
488
683
|
.enforcing()
|
|
489
684
|
.loadByFieldEqualingAsync('name', 'beforeAll')
|
|
490
685
|
).resolves.toBeNull();
|
|
491
686
|
|
|
492
687
|
await expect(
|
|
493
|
-
PostgresTriggerTestEntity.creator(
|
|
688
|
+
PostgresTriggerTestEntity.creator(
|
|
689
|
+
vc1,
|
|
690
|
+
vc1.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
|
|
691
|
+
)
|
|
692
|
+
.setField('name', 'afterAll')
|
|
693
|
+
.enforceCreateAsync()
|
|
494
694
|
).rejects.toThrowError('name cannot have value afterAll');
|
|
495
695
|
await expect(
|
|
496
|
-
PostgresTriggerTestEntity.loader(
|
|
696
|
+
PostgresTriggerTestEntity.loader(
|
|
697
|
+
vc1,
|
|
698
|
+
vc1.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
|
|
699
|
+
)
|
|
497
700
|
.enforcing()
|
|
498
701
|
.loadByFieldEqualingAsync('name', 'afterAll')
|
|
499
702
|
).resolves.toBeNull();
|
|
500
703
|
|
|
501
704
|
await expect(
|
|
502
|
-
PostgresTriggerTestEntity.creator(
|
|
705
|
+
PostgresTriggerTestEntity.creator(
|
|
706
|
+
vc1,
|
|
707
|
+
vc1.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
|
|
708
|
+
)
|
|
503
709
|
.setField('name', 'afterCommit')
|
|
504
710
|
.enforceCreateAsync()
|
|
505
711
|
).rejects.toThrowError('name cannot have value afterCommit');
|
|
506
712
|
await expect(
|
|
507
|
-
PostgresTriggerTestEntity.loader(
|
|
713
|
+
PostgresTriggerTestEntity.loader(
|
|
714
|
+
vc1,
|
|
715
|
+
vc1.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
|
|
716
|
+
)
|
|
508
717
|
.enforcing()
|
|
509
718
|
.loadByFieldEqualingAsync('name', 'afterCommit')
|
|
510
719
|
).resolves.not.toBeNull();
|
|
@@ -517,61 +726,94 @@ describe('postgres entity integration', () => {
|
|
|
517
726
|
createKnexIntegrationTestEntityCompanionProvider(knexInstance)
|
|
518
727
|
);
|
|
519
728
|
|
|
520
|
-
const entity = await PostgresTriggerTestEntity.creator(
|
|
729
|
+
const entity = await PostgresTriggerTestEntity.creator(
|
|
730
|
+
vc1,
|
|
731
|
+
vc1.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
|
|
732
|
+
)
|
|
521
733
|
.setField('name', 'blah')
|
|
522
734
|
.enforceCreateAsync();
|
|
523
735
|
|
|
524
736
|
await expect(
|
|
525
|
-
PostgresTriggerTestEntity.updater(
|
|
737
|
+
PostgresTriggerTestEntity.updater(
|
|
738
|
+
entity,
|
|
739
|
+
vc1.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
|
|
740
|
+
)
|
|
526
741
|
.setField('name', 'beforeUpdate')
|
|
527
742
|
.enforceUpdateAsync()
|
|
528
743
|
).rejects.toThrowError('name cannot have value beforeUpdate');
|
|
529
744
|
await expect(
|
|
530
|
-
PostgresTriggerTestEntity.loader(
|
|
745
|
+
PostgresTriggerTestEntity.loader(
|
|
746
|
+
vc1,
|
|
747
|
+
vc1.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
|
|
748
|
+
)
|
|
531
749
|
.enforcing()
|
|
532
750
|
.loadByFieldEqualingAsync('name', 'beforeUpdate')
|
|
533
751
|
).resolves.toBeNull();
|
|
534
752
|
|
|
535
753
|
await expect(
|
|
536
|
-
PostgresTriggerTestEntity.updater(
|
|
754
|
+
PostgresTriggerTestEntity.updater(
|
|
755
|
+
entity,
|
|
756
|
+
vc1.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
|
|
757
|
+
)
|
|
537
758
|
.setField('name', 'afterUpdate')
|
|
538
759
|
.enforceUpdateAsync()
|
|
539
760
|
).rejects.toThrowError('name cannot have value afterUpdate');
|
|
540
761
|
await expect(
|
|
541
|
-
PostgresTriggerTestEntity.loader(
|
|
762
|
+
PostgresTriggerTestEntity.loader(
|
|
763
|
+
vc1,
|
|
764
|
+
vc1.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
|
|
765
|
+
)
|
|
542
766
|
.enforcing()
|
|
543
767
|
.loadByFieldEqualingAsync('name', 'afterUpdate')
|
|
544
768
|
).resolves.toBeNull();
|
|
545
769
|
|
|
546
770
|
await expect(
|
|
547
|
-
PostgresTriggerTestEntity.updater(
|
|
771
|
+
PostgresTriggerTestEntity.updater(
|
|
772
|
+
entity,
|
|
773
|
+
vc1.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
|
|
774
|
+
)
|
|
548
775
|
.setField('name', 'beforeAll')
|
|
549
776
|
.enforceUpdateAsync()
|
|
550
777
|
).rejects.toThrowError('name cannot have value beforeAll');
|
|
551
778
|
await expect(
|
|
552
|
-
PostgresTriggerTestEntity.loader(
|
|
779
|
+
PostgresTriggerTestEntity.loader(
|
|
780
|
+
vc1,
|
|
781
|
+
vc1.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
|
|
782
|
+
)
|
|
553
783
|
.enforcing()
|
|
554
784
|
.loadByFieldEqualingAsync('name', 'beforeAll')
|
|
555
785
|
).resolves.toBeNull();
|
|
556
786
|
|
|
557
787
|
await expect(
|
|
558
|
-
PostgresTriggerTestEntity.updater(
|
|
788
|
+
PostgresTriggerTestEntity.updater(
|
|
789
|
+
entity,
|
|
790
|
+
vc1.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
|
|
791
|
+
)
|
|
559
792
|
.setField('name', 'afterAll')
|
|
560
793
|
.enforceUpdateAsync()
|
|
561
794
|
).rejects.toThrowError('name cannot have value afterAll');
|
|
562
795
|
await expect(
|
|
563
|
-
PostgresTriggerTestEntity.loader(
|
|
796
|
+
PostgresTriggerTestEntity.loader(
|
|
797
|
+
vc1,
|
|
798
|
+
vc1.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
|
|
799
|
+
)
|
|
564
800
|
.enforcing()
|
|
565
801
|
.loadByFieldEqualingAsync('name', 'afterAll')
|
|
566
802
|
).resolves.toBeNull();
|
|
567
803
|
|
|
568
804
|
await expect(
|
|
569
|
-
PostgresTriggerTestEntity.updater(
|
|
805
|
+
PostgresTriggerTestEntity.updater(
|
|
806
|
+
entity,
|
|
807
|
+
vc1.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
|
|
808
|
+
)
|
|
570
809
|
.setField('name', 'afterCommit')
|
|
571
810
|
.enforceUpdateAsync()
|
|
572
811
|
).rejects.toThrowError('name cannot have value afterCommit');
|
|
573
812
|
await expect(
|
|
574
|
-
PostgresTriggerTestEntity.loader(
|
|
813
|
+
PostgresTriggerTestEntity.loader(
|
|
814
|
+
vc1,
|
|
815
|
+
vc1.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
|
|
816
|
+
)
|
|
575
817
|
.enforcing()
|
|
576
818
|
.loadByFieldEqualingAsync('name', 'afterCommit')
|
|
577
819
|
).resolves.not.toBeNull();
|
|
@@ -584,26 +826,44 @@ describe('postgres entity integration', () => {
|
|
|
584
826
|
createKnexIntegrationTestEntityCompanionProvider(knexInstance)
|
|
585
827
|
);
|
|
586
828
|
|
|
587
|
-
const entityBeforeDelete = await PostgresTriggerTestEntity.creator(
|
|
829
|
+
const entityBeforeDelete = await PostgresTriggerTestEntity.creator(
|
|
830
|
+
vc1,
|
|
831
|
+
vc1.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
|
|
832
|
+
)
|
|
588
833
|
.setField('name', 'beforeDelete')
|
|
589
834
|
.enforceCreateAsync();
|
|
590
835
|
await expect(
|
|
591
|
-
PostgresTriggerTestEntity.enforceDeleteAsync(
|
|
836
|
+
PostgresTriggerTestEntity.enforceDeleteAsync(
|
|
837
|
+
entityBeforeDelete,
|
|
838
|
+
vc1.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
|
|
839
|
+
)
|
|
592
840
|
).rejects.toThrowError('name cannot have value beforeDelete');
|
|
593
841
|
await expect(
|
|
594
|
-
PostgresTriggerTestEntity.loader(
|
|
842
|
+
PostgresTriggerTestEntity.loader(
|
|
843
|
+
vc1,
|
|
844
|
+
vc1.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
|
|
845
|
+
)
|
|
595
846
|
.enforcing()
|
|
596
847
|
.loadByFieldEqualingAsync('name', 'beforeDelete')
|
|
597
848
|
).resolves.not.toBeNull();
|
|
598
849
|
|
|
599
|
-
const entityAfterDelete = await PostgresTriggerTestEntity.creator(
|
|
850
|
+
const entityAfterDelete = await PostgresTriggerTestEntity.creator(
|
|
851
|
+
vc1,
|
|
852
|
+
vc1.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
|
|
853
|
+
)
|
|
600
854
|
.setField('name', 'afterDelete')
|
|
601
855
|
.enforceCreateAsync();
|
|
602
856
|
await expect(
|
|
603
|
-
PostgresTriggerTestEntity.enforceDeleteAsync(
|
|
857
|
+
PostgresTriggerTestEntity.enforceDeleteAsync(
|
|
858
|
+
entityAfterDelete,
|
|
859
|
+
vc1.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
|
|
860
|
+
)
|
|
604
861
|
).rejects.toThrowError('name cannot have value afterDelete');
|
|
605
862
|
await expect(
|
|
606
|
-
PostgresTriggerTestEntity.loader(
|
|
863
|
+
PostgresTriggerTestEntity.loader(
|
|
864
|
+
vc1,
|
|
865
|
+
vc1.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
|
|
866
|
+
)
|
|
607
867
|
.enforcing()
|
|
608
868
|
.loadByFieldEqualingAsync('name', 'afterDelete')
|
|
609
869
|
).resolves.not.toBeNull();
|
|
@@ -617,12 +877,18 @@ describe('postgres entity integration', () => {
|
|
|
617
877
|
);
|
|
618
878
|
|
|
619
879
|
await expect(
|
|
620
|
-
PostgresValidatorTestEntity.creator(
|
|
880
|
+
PostgresValidatorTestEntity.creator(
|
|
881
|
+
vc1,
|
|
882
|
+
vc1.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
|
|
883
|
+
)
|
|
621
884
|
.setField('name', 'beforeCreateAndBeforeUpdate')
|
|
622
885
|
.enforceCreateAsync()
|
|
623
886
|
).rejects.toThrowError('name cannot have value beforeCreateAndBeforeUpdate');
|
|
624
887
|
await expect(
|
|
625
|
-
PostgresValidatorTestEntity.loader(
|
|
888
|
+
PostgresValidatorTestEntity.loader(
|
|
889
|
+
vc1,
|
|
890
|
+
vc1.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
|
|
891
|
+
)
|
|
626
892
|
.enforcing()
|
|
627
893
|
.loadByFieldEqualingAsync('name', 'beforeCreateAndBeforeUpdate')
|
|
628
894
|
).resolves.toBeNull();
|
|
@@ -634,17 +900,26 @@ describe('postgres entity integration', () => {
|
|
|
634
900
|
createKnexIntegrationTestEntityCompanionProvider(knexInstance)
|
|
635
901
|
);
|
|
636
902
|
|
|
637
|
-
const entity = await PostgresValidatorTestEntity.creator(
|
|
903
|
+
const entity = await PostgresValidatorTestEntity.creator(
|
|
904
|
+
vc1,
|
|
905
|
+
vc1.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
|
|
906
|
+
)
|
|
638
907
|
.setField('name', 'blah')
|
|
639
908
|
.enforceCreateAsync();
|
|
640
909
|
|
|
641
910
|
await expect(
|
|
642
|
-
PostgresValidatorTestEntity.updater(
|
|
911
|
+
PostgresValidatorTestEntity.updater(
|
|
912
|
+
entity,
|
|
913
|
+
vc1.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
|
|
914
|
+
)
|
|
643
915
|
.setField('name', 'beforeCreateAndBeforeUpdate')
|
|
644
916
|
.enforceUpdateAsync()
|
|
645
917
|
).rejects.toThrowError('name cannot have value beforeCreateAndBeforeUpdate');
|
|
646
918
|
await expect(
|
|
647
|
-
PostgresValidatorTestEntity.loader(
|
|
919
|
+
PostgresValidatorTestEntity.loader(
|
|
920
|
+
vc1,
|
|
921
|
+
vc1.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
|
|
922
|
+
)
|
|
648
923
|
.enforcing()
|
|
649
924
|
.loadByFieldEqualingAsync('name', 'beforeCreateAndBeforeUpdate')
|
|
650
925
|
).resolves.toBeNull();
|
|
@@ -656,12 +931,21 @@ describe('postgres entity integration', () => {
|
|
|
656
931
|
createKnexIntegrationTestEntityCompanionProvider(knexInstance)
|
|
657
932
|
);
|
|
658
933
|
|
|
659
|
-
const entityToDelete = await PostgresValidatorTestEntity.creator(
|
|
934
|
+
const entityToDelete = await PostgresValidatorTestEntity.creator(
|
|
935
|
+
vc1,
|
|
936
|
+
vc1.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
|
|
937
|
+
)
|
|
660
938
|
.setField('name', 'shouldBeDeleted')
|
|
661
939
|
.enforceCreateAsync();
|
|
662
|
-
await PostgresValidatorTestEntity.enforceDeleteAsync(
|
|
940
|
+
await PostgresValidatorTestEntity.enforceDeleteAsync(
|
|
941
|
+
entityToDelete,
|
|
942
|
+
vc1.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
|
|
943
|
+
);
|
|
663
944
|
await expect(
|
|
664
|
-
PostgresValidatorTestEntity.loader(
|
|
945
|
+
PostgresValidatorTestEntity.loader(
|
|
946
|
+
vc1,
|
|
947
|
+
vc1.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
|
|
948
|
+
)
|
|
665
949
|
.enforcing()
|
|
666
950
|
.loadByFieldEqualingAsync('name', 'shouldBeDeleted')
|
|
667
951
|
).resolves.toBeNull();
|