Skip to content

Commit 0c001e3

Browse files
fadi-georgefadi-george
committed
change execution response to interface
1 parent c897303 commit 0c001e3

16 files changed

+225
-260
lines changed

‎package.json‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -84,7 +84,7 @@
8484
},
8585
{
8686
"path": "./build/releases/OneSignalSDK.page.es6.js",
87-
"limit": "46.34 kB",
87+
"limit": "46.281 kB",
8888
"gzip": true
8989
},
9090
{

‎src/core/executors/CustomEventOperationExecutor.ts‎

Lines changed: 4 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -10,11 +10,11 @@ import {
1010
import Log from 'src/shared/libraries/Log';
1111
import { VERSION } from 'src/shared/utils/env';
1212
import { OPERATION_NAME } from '../constants';
13-
import { ExecutionResponse } from '../operations/ExecutionResponse';
1413
import { Operation } from '../operations/Operation';
1514
import { TrackCustomEventOperation } from '../operations/TrackCustomEventOperation';
1615
import { sendCustomEvent } from '../requests/api';
1716
import type { ICustomEventMetadata } from '../types/customEvents';
17+
import type { ExecutionResponse } from '../types/operation';
1818
import { ExecutionResult, type IOperationExecutor } from '../types/operation';
1919

2020
// Implements logic similar to Android SDK's CustomEventOperationExecutor
@@ -66,13 +66,13 @@ export class CustomEventsOperationExecutor implements IOperationExecutor {
6666
const { ok, status } = response;
6767
const responseType = getResponseStatusType(status);
6868

69-
if (ok) return new ExecutionResponse(ExecutionResult._Success);
69+
if (ok) return { _result: ExecutionResult._Success };
7070

7171
switch (responseType) {
7272
case ResponseStatusType._Retryable:
73-
return new ExecutionResponse(ExecutionResult._FailRetry);
73+
return { _result: ExecutionResult._FailRetry };
7474
default:
75-
return new ExecutionResponse(ExecutionResult._FailNoretry);
75+
return { _result: ExecutionResult._FailNoretry };
7676
}
7777
}
7878
}

‎src/core/executors/IdentityOperationExecutor.test.ts‎

Lines changed: 23 additions & 23 deletions
Original file line numberDiff line numberDiff line change
@@ -127,25 +127,25 @@ describe('IdentityOperationExecutor', () => {
127127
// Retryable
128128
setAddAliasError({ status: 429, retryAfter: 10 });
129129
const res = await executor._execute(ops);
130-
expect(res.result).toBe(ExecutionResult._FailRetry);
131-
expect(res.retryAfterSeconds).toBe(10);
130+
expect(res._result).toBe(ExecutionResult._FailRetry);
131+
expect(res._retryAfterSeconds).toBe(10);
132132

133133
// Invalid
134134
setAddAliasError({ status: 400 });
135135
const res2 = await executor._execute(ops);
136-
expect(res2.result).toBe(ExecutionResult._FailNoretry);
136+
expect(res2._result).toBe(ExecutionResult._FailNoretry);
137137

138138
// Conflict
139139
setAddAliasError({ status: 409, retryAfter: 5 });
140140
const res3 = await executor._execute(ops);
141-
expect(res3.result).toBe(ExecutionResult._FailConflict);
142-
expect(res3.retryAfterSeconds).toBe(5);
141+
expect(res3._result).toBe(ExecutionResult._FailConflict);
142+
expect(res3._retryAfterSeconds).toBe(5);
143143

144144
// Unauthorized
145145
setAddAliasError({ status: 401, retryAfter: 15 });
146146
const res4 = await executor._execute(ops);
147-
expect(res4.result).toBe(ExecutionResult._FailUnauthorized);
148-
expect(res4.retryAfterSeconds).toBe(15);
147+
expect(res4._result).toBe(ExecutionResult._FailUnauthorized);
148+
expect(res4._retryAfterSeconds).toBe(15);
149149

150150
// Missing
151151
setAddAliasError({ status: 410 });
@@ -154,15 +154,15 @@ describe('IdentityOperationExecutor', () => {
154154

155155
// no rebuild ops
156156
updateIdentityModel('onesignal_id', undefined);
157-
expect(res5.result).toBe(ExecutionResult._FailNoretry);
158-
expect(res5.retryAfterSeconds).toBeUndefined();
157+
expect(res5._result).toBe(ExecutionResult._FailNoretry);
158+
expect(res5._retryAfterSeconds).toBeUndefined();
159159

160160
// with rebuild ops
161161
identityModelStore._model._onesignalId = ONESIGNAL_ID;
162162
const res7 = await executor._execute(ops);
163-
expect(res7.result).toBe(ExecutionResult._FailRetry);
164-
expect(res7.retryAfterSeconds).toBeUndefined();
165-
expect(res7.operations).toMatchObject([
163+
expect(res7._result).toBe(ExecutionResult._FailRetry);
164+
expect(res7._retryAfterSeconds).toBeUndefined();
165+
expect(res7._operations).toMatchObject([
166166
{
167167
_name: 'login-user',
168168
_appId: APP_ID,
@@ -179,8 +179,8 @@ describe('IdentityOperationExecutor', () => {
179179
newRecordsState._add(ONESIGNAL_ID);
180180
setAddAliasError({ status: 404, retryAfter: 20 });
181181
const res6 = await executor._execute(ops);
182-
expect(res6.result).toBe(ExecutionResult._FailRetry);
183-
expect(res6.retryAfterSeconds).toBe(20);
182+
expect(res6._result).toBe(ExecutionResult._FailRetry);
183+
expect(res6._retryAfterSeconds).toBe(20);
184184
});
185185

186186
test('should handle deleteAlias errors', async () => {
@@ -190,36 +190,36 @@ describe('IdentityOperationExecutor', () => {
190190
// Retryable
191191
setDeleteAliasError({ status: 429, retryAfter: 10 });
192192
const res = await executor._execute(ops);
193-
expect(res.result).toBe(ExecutionResult._FailRetry);
194-
expect(res.retryAfterSeconds).toBe(10);
193+
expect(res._result).toBe(ExecutionResult._FailRetry);
194+
expect(res._retryAfterSeconds).toBe(10);
195195

196196
// Invalid
197197
setDeleteAliasError({ status: 400 });
198198
const res2 = await executor._execute(ops);
199-
expect(res2.result).toBe(ExecutionResult._FailNoretry);
199+
expect(res2._result).toBe(ExecutionResult._FailNoretry);
200200

201201
// Conflict
202202
setDeleteAliasError({ status: 409, retryAfter: 5 });
203203
const res3 = await executor._execute(ops);
204-
expect(res3.result).toBe(ExecutionResult._Success);
204+
expect(res3._result).toBe(ExecutionResult._Success);
205205

206206
// Unauthorized
207207
setDeleteAliasError({ status: 401, retryAfter: 15 });
208208
const res4 = await executor._execute(ops);
209-
expect(res4.result).toBe(ExecutionResult._FailUnauthorized);
210-
expect(res4.retryAfterSeconds).toBe(15);
209+
expect(res4._result).toBe(ExecutionResult._FailUnauthorized);
210+
expect(res4._retryAfterSeconds).toBe(15);
211211

212212
// Missing
213213
setDeleteAliasError({ status: 410 });
214214
const res5 = await executor._execute(ops);
215-
expect(res5.result).toBe(ExecutionResult._Success);
215+
expect(res5._result).toBe(ExecutionResult._Success);
216216

217217
// in missing retry window
218218
newRecordsState._add(ONESIGNAL_ID);
219219
setDeleteAliasError({ status: 404, retryAfter: 20 });
220220
const res6 = await executor._execute(ops);
221-
expect(res6.result).toBe(ExecutionResult._FailRetry);
222-
expect(res6.retryAfterSeconds).toBe(20);
221+
expect(res6._result).toBe(ExecutionResult._FailRetry);
222+
expect(res6._retryAfterSeconds).toBe(20);
223223
});
224224
});
225225
});

‎src/core/executors/IdentityOperationExecutor.ts‎

Lines changed: 27 additions & 27 deletions
Original file line numberDiff line numberDiff line change
@@ -13,10 +13,10 @@ import { IdentityConstants, OPERATION_NAME } from '../constants';
1313
import { type IdentityModelStore } from '../modelStores/IdentityModelStore';
1414
import { type NewRecordsState } from '../operationRepo/NewRecordsState';
1515
import { DeleteAliasOperation } from '../operations/DeleteAliasOperation';
16-
import { ExecutionResponse } from '../operations/ExecutionResponse';
1716
import { type Operation } from '../operations/Operation';
1817
import { SetAliasOperation } from '../operations/SetAliasOperation';
1918
import { addAlias, deleteAlias } from '../requests/api';
19+
import type { ExecutionResponse } from '../types/operation';
2020

2121
// Implements logic similar to Android SDK's IdentityOperationExecutor
2222
// Reference: https://github.com/OneSignal/OneSignal-Android-SDK/blob/5.1.31/OneSignalSDK/onesignal/core/src/main/java/com/onesignal/user/internal/operations/impl/executors/IdentityOperationExecutor.kt
@@ -105,33 +105,33 @@ export class IdentityOperationExecutor implements IOperationExecutor {
105105
ModelChangeTags._Hydrate,
106106
);
107107
}
108-
return new ExecutionResponse(ExecutionResult._Success);
108+
return { _result: ExecutionResult._Success };
109109
}
110110

111111
const responseType = getResponseStatusType(status);
112112
switch (responseType) {
113113
case ResponseStatusType._Retryable:
114-
return new ExecutionResponse(
115-
ExecutionResult._FailRetry,
116-
retryAfterSeconds,
117-
);
114+
return {
115+
_result: ExecutionResult._FailRetry,
116+
_retryAfterSeconds: retryAfterSeconds,
117+
};
118118
case ResponseStatusType._Invalid:
119-
return new ExecutionResponse(ExecutionResult._FailNoretry);
119+
return { _result: ExecutionResult._FailNoretry };
120120

121121
case ResponseStatusType._Conflict: {
122122
if (isSetAlias)
123-
return new ExecutionResponse(
124-
ExecutionResult._FailConflict,
125-
retryAfterSeconds,
126-
);
127-
return new ExecutionResponse(ExecutionResult._Success); // alias doesn't exist = good
123+
return {
124+
_result: ExecutionResult._FailConflict,
125+
_retryAfterSeconds: retryAfterSeconds,
126+
};
127+
return { _result: ExecutionResult._Success }; // alias doesn't exist = good
128128
}
129129

130130
case ResponseStatusType._Unauthorized:
131-
return new ExecutionResponse(
132-
ExecutionResult._FailUnauthorized,
133-
retryAfterSeconds,
134-
);
131+
return {
132+
_result: ExecutionResult._FailUnauthorized,
133+
_retryAfterSeconds: retryAfterSeconds,
134+
};
135135

136136
case ResponseStatusType._Missing: {
137137
if (
@@ -140,10 +140,10 @@ export class IdentityOperationExecutor implements IOperationExecutor {
140140
lastOperation._onesignalId,
141141
)
142142
)
143-
return new ExecutionResponse(
144-
ExecutionResult._FailRetry,
145-
retryAfterSeconds,
146-
);
143+
return {
144+
_result: ExecutionResult._FailRetry,
145+
_retryAfterSeconds: retryAfterSeconds,
146+
};
147147

148148
if (isSetAlias) {
149149
const rebuildOps =
@@ -153,19 +153,19 @@ export class IdentityOperationExecutor implements IOperationExecutor {
153153
);
154154

155155
if (rebuildOps == null)
156-
return new ExecutionResponse(ExecutionResult._FailNoretry);
156+
return { _result: ExecutionResult._FailNoretry };
157157

158-
return new ExecutionResponse(
159-
ExecutionResult._FailRetry,
160-
retryAfterSeconds,
161-
rebuildOps,
162-
);
158+
return {
159+
_result: ExecutionResult._FailRetry,
160+
_retryAfterSeconds: retryAfterSeconds,
161+
_operations: rebuildOps,
162+
};
163163
}
164164

165165
// This means either the User or the Alias was already
166166
// deleted, either way the end state is the same, the
167167
// alias no longer exists on that User.
168-
return new ExecutionResponse(ExecutionResult._Success);
168+
return { _result: ExecutionResult._Success };
169169
}
170170
}
171171
}

‎src/core/executors/LoginUserOperationExecutor.test.ts‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -204,7 +204,7 @@ describe('LoginUserOperationExecutor', () => {
204204

205205
// should have a refresh user operation
206206
const refreshOp = new RefreshUserOperation(APP_ID, ONESIGNAL_ID_2);
207-
refreshOp._modelId = res.operations![0]._modelId;
207+
refreshOp._modelId = res._operations![0]._modelId;
208208
expect(res).toEqual({
209209
result: ExecutionResult._Success,
210210
retryAfterSeconds: undefined,

‎src/core/executors/LoginUserOperationExecutor.ts‎

Lines changed: 21 additions & 24 deletions
Original file line numberDiff line numberDiff line change
@@ -17,7 +17,6 @@ import { PropertiesModelStore } from '../modelStores/PropertiesModelStore';
1717
import { type SubscriptionModelStore } from '../modelStores/SubscriptionModelStore';
1818
import { CreateSubscriptionOperation } from '../operations/CreateSubscriptionOperation';
1919
import { DeleteSubscriptionOperation } from '../operations/DeleteSubscriptionOperation';
20-
import { ExecutionResponse } from '../operations/ExecutionResponse';
2120
import { LoginUserOperation } from '../operations/LoginUserOperation';
2221
import { type Operation } from '../operations/Operation';
2322
import { RefreshUserOperation } from '../operations/RefreshUserOperation';
@@ -30,6 +29,7 @@ import type {
3029
ICreateUserSubscription,
3130
IUserProperties,
3231
} from '../types/api';
32+
import type { ExecutionResponse } from '../types/operation';
3333
import { type IdentityOperationExecutor } from './IdentityOperationExecutor';
3434

3535
type SubscriptionMap = Record<
@@ -93,7 +93,7 @@ export class LoginUserOperationExecutor implements IOperationExecutor {
9393
),
9494
]);
9595

96-
switch (result.result) {
96+
switch (result._result) {
9797
case ExecutionResult._Success: {
9898
const backendOneSignalId = loginUserOp.existingOnesignalId;
9999
const opOneSignalId = loginUserOp._onesignalId;
@@ -113,14 +113,12 @@ export class LoginUserOperationExecutor implements IOperationExecutor {
113113
ModelChangeTags._Hydrate,
114114
);
115115
}
116-
return new ExecutionResponse(
117-
ExecutionResult._SuccessStartingOnly,
118-
undefined,
119-
undefined,
120-
{
116+
return {
117+
_result: ExecutionResult._SuccessStartingOnly,
118+
_idTranslations: {
121119
[loginUserOp._onesignalId]: backendOneSignalId,
122120
},
123-
);
121+
};
124122
}
125123

126124
case ExecutionResult._FailConflict:
@@ -134,7 +132,7 @@ export class LoginUserOperationExecutor implements IOperationExecutor {
134132
return this._createUser(loginUserOp, operations);
135133

136134
default:
137-
return new ExecutionResponse(result.result);
135+
return { _result: result._result };
138136
}
139137
}
140138

@@ -244,30 +242,29 @@ export class LoginUserOperationExecutor implements IOperationExecutor {
244242
]
245243
: undefined;
246244

247-
return new ExecutionResponse(
248-
ExecutionResult._Success,
249-
undefined,
250-
followUp,
251-
idTranslations,
252-
);
245+
return {
246+
_result: ExecutionResult._Success,
247+
_operations: followUp,
248+
_idTranslations: idTranslations,
249+
};
253250
}
254251

255252
const { status, retryAfterSeconds } = response;
256253
const responseType = getResponseStatusType(status);
257254

258255
switch (responseType) {
259256
case ResponseStatusType._Retryable:
260-
return new ExecutionResponse(
261-
ExecutionResult._FailRetry,
262-
retryAfterSeconds,
263-
);
257+
return {
258+
_result: ExecutionResult._FailRetry,
259+
_retryAfterSeconds: retryAfterSeconds,
260+
};
264261
case ResponseStatusType._Unauthorized:
265-
return new ExecutionResponse(
266-
ExecutionResult._FailUnauthorized,
267-
retryAfterSeconds,
268-
);
262+
return {
263+
_result: ExecutionResult._FailUnauthorized,
264+
_retryAfterSeconds: retryAfterSeconds,
265+
};
269266
default:
270-
return new ExecutionResponse(ExecutionResult._FailPauseOpRepo);
267+
return { _result: ExecutionResult._FailPauseOpRepo };
271268
}
272269
}
273270

‎src/core/executors/RefreshUserOperationExecutor.test.ts‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -107,7 +107,7 @@ describe('RefreshUserOperationExecutor', () => {
107107
const refreshOp = new RefreshUserOperation(APP_ID, ONESIGNAL_ID_2);
108108

109109
const result = await executor._execute([refreshOp]);
110-
expect(result.result).toBe(ExecutionResult._Success);
110+
expect(result._result).toBe(ExecutionResult._Success);
111111
expect(propertiesModelStore._model._language).not.toBe('fr');
112112
});
113113

@@ -141,7 +141,7 @@ describe('RefreshUserOperationExecutor', () => {
141141
const refreshOp = new RefreshUserOperation(APP_ID, ONESIGNAL_ID);
142142

143143
const result = await executor._execute([refreshOp]);
144-
expect(result.result).toBe(ExecutionResult._Success);
144+
expect(result._result).toBe(ExecutionResult._Success);
145145

146146
// Check identity model updates
147147
expect(identityModelStore._model._getProperty('onesignal_id')).toBe(

0 commit comments

Comments
 (0)