@friggframework/core 2.0.0--canary.654.70623e2.0 → 2.0.0--canary.656.10f1676.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/CLAUDE.md +132 -1
- package/core/CLAUDE.md +5 -2
- package/core/Worker.js +2 -1
- package/core/index.js +6 -0
- package/core/invocation-deadline.js +56 -0
- package/core/invocation-scope.js +24 -15
- package/database/documentdb-encryption-service.js +6 -2
- package/database/documentdb-utils.js +2 -1
- package/database/encryption/README.md +20 -0
- package/database/encryption/integration-mapping-encryption.js +97 -0
- package/database/encryption/prisma-encryption-extension.js +20 -9
- package/errors/fetch-error.js +12 -6
- package/errors/index.js +2 -0
- package/errors/rate-limit-error.js +44 -0
- package/handlers/backend-utils.js +4 -2
- package/handlers/integration-event-dispatcher.js +2 -2
- package/index.js +18 -0
- package/integrations/repositories/integration-mapping-query-pipeline.js +152 -0
- package/integrations/repositories/integration-mapping-query.js +193 -0
- package/integrations/repositories/integration-mapping-repository-documentdb.js +53 -0
- package/integrations/repositories/integration-mapping-repository-interface.js +48 -0
- package/integrations/repositories/integration-mapping-repository-mongo.js +72 -0
- package/integrations/repositories/integration-mapping-repository-postgres.js +118 -0
- package/logs/record.js +32 -7
- package/modules/requester/rate-limit/index.js +4 -0
- package/modules/requester/rate-limit/parsers.js +268 -0
- package/modules/requester/rate-limit/policy.js +323 -0
- package/modules/requester/requester.js +174 -6
- package/package.json +5 -5
- package/queues/queue-delivery.js +41 -0
- package/types/core/index.d.ts +42 -0
- package/types/errors/index.d.ts +56 -0
- package/types/module-plugin/index.d.ts +52 -0
|
@@ -18,9 +18,9 @@ class IntegrationEventDispatcher {
|
|
|
18
18
|
);
|
|
19
19
|
}
|
|
20
20
|
|
|
21
|
-
async dispatchJob({ event, data, context }) {
|
|
21
|
+
async dispatchJob({ event, data, context, delivery }) {
|
|
22
22
|
return this._dispatch(event, (instance, handler) =>
|
|
23
|
-
handler.call(instance, { data, context })
|
|
23
|
+
handler.call(instance, { data, context, delivery })
|
|
24
24
|
);
|
|
25
25
|
}
|
|
26
26
|
|
package/index.js
CHANGED
|
@@ -12,6 +12,8 @@ const {
|
|
|
12
12
|
loadInstalledModules,
|
|
13
13
|
createHandler,
|
|
14
14
|
runInvocationScope,
|
|
15
|
+
runWithInvocationDeadline,
|
|
16
|
+
remainingInvocationMs,
|
|
15
17
|
} = require('./core/index');
|
|
16
18
|
const {
|
|
17
19
|
prisma,
|
|
@@ -55,6 +57,7 @@ const {
|
|
|
55
57
|
BaseError,
|
|
56
58
|
FetchError,
|
|
57
59
|
HaltError,
|
|
60
|
+
RateLimitError,
|
|
58
61
|
RequiredPropertyError,
|
|
59
62
|
ParameterTypeError,
|
|
60
63
|
} = require('./errors/index');
|
|
@@ -100,6 +103,12 @@ const {
|
|
|
100
103
|
ModuleConstants,
|
|
101
104
|
ModuleFactory,
|
|
102
105
|
} = require('./modules/index');
|
|
106
|
+
const {
|
|
107
|
+
classifyRateLimit,
|
|
108
|
+
parseRetryAfter,
|
|
109
|
+
parseResetHeaders,
|
|
110
|
+
parseIetfRateLimit,
|
|
111
|
+
} = require('./modules/requester/rate-limit');
|
|
103
112
|
const application = require('./application');
|
|
104
113
|
const utils = require('./utils');
|
|
105
114
|
|
|
@@ -120,6 +129,8 @@ module.exports = {
|
|
|
120
129
|
loadInstalledModules,
|
|
121
130
|
createHandler,
|
|
122
131
|
runInvocationScope,
|
|
132
|
+
runWithInvocationDeadline,
|
|
133
|
+
remainingInvocationMs,
|
|
123
134
|
|
|
124
135
|
// database
|
|
125
136
|
prisma,
|
|
@@ -142,9 +153,16 @@ module.exports = {
|
|
|
142
153
|
BaseError,
|
|
143
154
|
FetchError,
|
|
144
155
|
HaltError,
|
|
156
|
+
RateLimitError,
|
|
145
157
|
RequiredPropertyError,
|
|
146
158
|
ParameterTypeError,
|
|
147
159
|
|
|
160
|
+
// rate limit
|
|
161
|
+
classifyRateLimit,
|
|
162
|
+
parseRetryAfter,
|
|
163
|
+
parseResetHeaders,
|
|
164
|
+
parseIetfRateLimit,
|
|
165
|
+
|
|
148
166
|
// integrations
|
|
149
167
|
IntegrationBase,
|
|
150
168
|
Options,
|
|
@@ -0,0 +1,152 @@
|
|
|
1
|
+
const SORT_KEY = '__sortKey';
|
|
2
|
+
const MONGO_DIRECTIONS = { asc: 1, desc: -1 };
|
|
3
|
+
const SORT_TYPE_RANKS = [
|
|
4
|
+
['string'],
|
|
5
|
+
['int', 'long', 'double', 'decimal'],
|
|
6
|
+
['bool'],
|
|
7
|
+
['array'],
|
|
8
|
+
['object'],
|
|
9
|
+
];
|
|
10
|
+
const SCALAR_TYPES = SORT_TYPE_RANKS.slice(0, 3).flat();
|
|
11
|
+
|
|
12
|
+
const isType = (expression, type) => ({ $eq: [{ $type: expression }, type] });
|
|
13
|
+
const isAbsent = (expression) => ({
|
|
14
|
+
$eq: [{ $ifNull: [expression, null] }, null],
|
|
15
|
+
});
|
|
16
|
+
const mappingField = (segments) => `$mapping.${segments.join('.')}`;
|
|
17
|
+
|
|
18
|
+
const CONDITION_EXPRESSIONS = {
|
|
19
|
+
exists: (operand) => ({ $ne: [{ $ifNull: [operand, null] }, null] }),
|
|
20
|
+
notExists: (operand) => isAbsent(operand),
|
|
21
|
+
in: (operand, values) => ({
|
|
22
|
+
$and: [
|
|
23
|
+
isType(operand, 'string'),
|
|
24
|
+
{ $in: [operand, { $literal: values }] },
|
|
25
|
+
],
|
|
26
|
+
}),
|
|
27
|
+
notStartsWith: (operand, prefix) => ({
|
|
28
|
+
$cond: [
|
|
29
|
+
isType(operand, 'string'),
|
|
30
|
+
{
|
|
31
|
+
$ne: [
|
|
32
|
+
{ $substrCP: [operand, 0, [...prefix].length] },
|
|
33
|
+
{ $literal: prefix },
|
|
34
|
+
],
|
|
35
|
+
},
|
|
36
|
+
true,
|
|
37
|
+
],
|
|
38
|
+
}),
|
|
39
|
+
};
|
|
40
|
+
|
|
41
|
+
/**
|
|
42
|
+
* Aggregation stages that answer a validated queryMappings query on the
|
|
43
|
+
* MongoDB wire protocol.
|
|
44
|
+
*
|
|
45
|
+
* @param {*} integrationId - The value IntegrationMapping.integrationId is stored as
|
|
46
|
+
* @param {ReturnType<import('./integration-mapping-query').validateMappingQuery>} query
|
|
47
|
+
* @returns {{match: Object, page: Object[], sort: Object}} `match` selects
|
|
48
|
+
* the matching documents; `page` sorts, skips and limits them; `sort` is
|
|
49
|
+
* the $sort stage inside `page`
|
|
50
|
+
*/
|
|
51
|
+
function buildMappingQueryStages(
|
|
52
|
+
integrationId,
|
|
53
|
+
{ where, orderBy, skip, take, omit }
|
|
54
|
+
) {
|
|
55
|
+
const match = {
|
|
56
|
+
$match: {
|
|
57
|
+
integrationId,
|
|
58
|
+
$expr: {
|
|
59
|
+
$and: [
|
|
60
|
+
isType('$mapping', 'object'),
|
|
61
|
+
...where.map(entryExpression),
|
|
62
|
+
],
|
|
63
|
+
},
|
|
64
|
+
},
|
|
65
|
+
};
|
|
66
|
+
const sort = { $sort: sortSpec(orderBy) };
|
|
67
|
+
const page = [
|
|
68
|
+
...(orderBy
|
|
69
|
+
? [{ $addFields: { [SORT_KEY]: sortKey(orderBy.path) } }]
|
|
70
|
+
: []),
|
|
71
|
+
...(omit.length > 0 ? [{ $project: omitProjection(omit) }] : []),
|
|
72
|
+
sort,
|
|
73
|
+
...(skip > 0 ? [{ $skip: skip }] : []),
|
|
74
|
+
{ $limit: take },
|
|
75
|
+
];
|
|
76
|
+
return { match, page, sort };
|
|
77
|
+
}
|
|
78
|
+
|
|
79
|
+
function entryExpression(entry) {
|
|
80
|
+
if (!entry.anyOf) return conditionExpression(entry);
|
|
81
|
+
return { $or: entry.anyOf.map(conditionExpression) };
|
|
82
|
+
}
|
|
83
|
+
|
|
84
|
+
function conditionExpression({ field, path, op, value }) {
|
|
85
|
+
const operand = field === 'sourceId' ? '$sourceId' : resolvePath(path);
|
|
86
|
+
return CONDITION_EXPRESSIONS[op](operand, value);
|
|
87
|
+
}
|
|
88
|
+
|
|
89
|
+
/**
|
|
90
|
+
* The value at a mapping path; null when an enclosing value is not an object.
|
|
91
|
+
*/
|
|
92
|
+
function resolvePath(segments) {
|
|
93
|
+
const enclosing = segments
|
|
94
|
+
.slice(0, -1)
|
|
95
|
+
.map((_, i) =>
|
|
96
|
+
isType(mappingField(segments.slice(0, i + 1)), 'object')
|
|
97
|
+
);
|
|
98
|
+
if (enclosing.length === 0) return mappingField(segments);
|
|
99
|
+
return {
|
|
100
|
+
$cond: [
|
|
101
|
+
enclosing.length === 1 ? enclosing[0] : { $and: enclosing },
|
|
102
|
+
mappingField(segments),
|
|
103
|
+
null,
|
|
104
|
+
],
|
|
105
|
+
};
|
|
106
|
+
}
|
|
107
|
+
|
|
108
|
+
/**
|
|
109
|
+
* Orders values like jsonb: strings < numbers < booleans < arrays < objects,
|
|
110
|
+
* scalars by value within their type. Null and absent values sort last in
|
|
111
|
+
* both directions.
|
|
112
|
+
*/
|
|
113
|
+
function sortKey(path) {
|
|
114
|
+
const type = { $type: '$$value' };
|
|
115
|
+
return {
|
|
116
|
+
$let: {
|
|
117
|
+
vars: { value: resolvePath(path) },
|
|
118
|
+
in: {
|
|
119
|
+
missing: isAbsent('$$value'),
|
|
120
|
+
rank: {
|
|
121
|
+
$switch: {
|
|
122
|
+
branches: SORT_TYPE_RANKS.map((types, i) => ({
|
|
123
|
+
case: { $in: [type, types] },
|
|
124
|
+
then: i + 1,
|
|
125
|
+
})),
|
|
126
|
+
default: 0,
|
|
127
|
+
},
|
|
128
|
+
},
|
|
129
|
+
value: {
|
|
130
|
+
$cond: [{ $in: [type, SCALAR_TYPES] }, '$$value', null],
|
|
131
|
+
},
|
|
132
|
+
},
|
|
133
|
+
},
|
|
134
|
+
};
|
|
135
|
+
}
|
|
136
|
+
|
|
137
|
+
function sortSpec(orderBy) {
|
|
138
|
+
if (!orderBy) return { _id: 1 };
|
|
139
|
+
const direction = MONGO_DIRECTIONS[orderBy.direction];
|
|
140
|
+
return {
|
|
141
|
+
[`${SORT_KEY}.missing`]: 1,
|
|
142
|
+
[`${SORT_KEY}.rank`]: direction,
|
|
143
|
+
[`${SORT_KEY}.value`]: direction,
|
|
144
|
+
_id: direction,
|
|
145
|
+
};
|
|
146
|
+
}
|
|
147
|
+
|
|
148
|
+
function omitProjection(omit) {
|
|
149
|
+
return Object.fromEntries(omit.map((key) => [`mapping.${key}`, 0]));
|
|
150
|
+
}
|
|
151
|
+
|
|
152
|
+
module.exports = { buildMappingQueryStages };
|
|
@@ -0,0 +1,193 @@
|
|
|
1
|
+
const SEGMENT_REGEX = /^[A-Za-z_][A-Za-z0-9_]*$/;
|
|
2
|
+
const MAX_TAKE = 500;
|
|
3
|
+
const MAX_IN_VALUES = 500;
|
|
4
|
+
const MAX_CONDITIONS = 20;
|
|
5
|
+
const DIRECTIONS = ['asc', 'desc'];
|
|
6
|
+
|
|
7
|
+
const OPERATORS = {
|
|
8
|
+
exists: { fields: ['mapping'] },
|
|
9
|
+
notExists: { fields: ['mapping'] },
|
|
10
|
+
in: { fields: ['mapping'], value: toStringList },
|
|
11
|
+
notStartsWith: { fields: ['sourceId'], value: toPrefix },
|
|
12
|
+
};
|
|
13
|
+
|
|
14
|
+
/**
|
|
15
|
+
* Checks a queryMappings query and normalizes it for an adapter.
|
|
16
|
+
*
|
|
17
|
+
* @param {Object} query - See IntegrationMappingRepositoryInterface.queryMappings
|
|
18
|
+
* @returns {{where: Array<Object>, orderBy: ({path: string[], direction: 'asc'|'desc'}|null), skip: number, take: number, omit: string[]}}
|
|
19
|
+
* @throws {Error} When the query does not fit that shape
|
|
20
|
+
*/
|
|
21
|
+
function validateMappingQuery(query) {
|
|
22
|
+
if (!isPlainObject(query)) {
|
|
23
|
+
throw new Error('queryMappings: query must be an object');
|
|
24
|
+
}
|
|
25
|
+
const { where = [], orderBy, skip = 0, take, omit = [] } = query;
|
|
26
|
+
if (!Array.isArray(where)) {
|
|
27
|
+
throw new Error('queryMappings: where must be an array');
|
|
28
|
+
}
|
|
29
|
+
if (!Number.isInteger(take) || take < 1 || take > MAX_TAKE) {
|
|
30
|
+
throw new Error(
|
|
31
|
+
`queryMappings: take must be an integer between 1 and ${MAX_TAKE}`
|
|
32
|
+
);
|
|
33
|
+
}
|
|
34
|
+
if (!Number.isSafeInteger(skip) || skip < 0) {
|
|
35
|
+
throw new Error('queryMappings: skip must be a non-negative integer');
|
|
36
|
+
}
|
|
37
|
+
if (
|
|
38
|
+
!Array.isArray(omit) ||
|
|
39
|
+
!omit.every((key) => typeof key === 'string' && SEGMENT_REGEX.test(key))
|
|
40
|
+
) {
|
|
41
|
+
throw new Error(
|
|
42
|
+
`queryMappings: omit must be an array of top-level mapping keys matching ${SEGMENT_REGEX}`
|
|
43
|
+
);
|
|
44
|
+
}
|
|
45
|
+
|
|
46
|
+
const whereEntries = where.map(toWhereEntry);
|
|
47
|
+
const conditionCount = whereEntries.reduce(
|
|
48
|
+
(count, entry) => count + (entry.anyOf ? entry.anyOf.length : 1),
|
|
49
|
+
0
|
|
50
|
+
);
|
|
51
|
+
if (conditionCount > MAX_CONDITIONS) {
|
|
52
|
+
throw new Error(
|
|
53
|
+
`queryMappings: where must have at most ${MAX_CONDITIONS} conditions, anyOf members included`
|
|
54
|
+
);
|
|
55
|
+
}
|
|
56
|
+
|
|
57
|
+
return {
|
|
58
|
+
where: whereEntries,
|
|
59
|
+
orderBy: orderBy === undefined ? null : toOrderBy(orderBy),
|
|
60
|
+
skip,
|
|
61
|
+
take,
|
|
62
|
+
omit,
|
|
63
|
+
};
|
|
64
|
+
}
|
|
65
|
+
|
|
66
|
+
function toOrderBy(orderBy) {
|
|
67
|
+
if (!isPlainObject(orderBy)) {
|
|
68
|
+
throw new Error('queryMappings: orderBy must be an object');
|
|
69
|
+
}
|
|
70
|
+
const { field, segments } = parsePath(orderBy.path);
|
|
71
|
+
if (field !== 'mapping') {
|
|
72
|
+
throw new Error(
|
|
73
|
+
"queryMappings: orderBy.path must be a mapping path ('mapping.<segment>...')"
|
|
74
|
+
);
|
|
75
|
+
}
|
|
76
|
+
if (!DIRECTIONS.includes(orderBy.direction)) {
|
|
77
|
+
throw new Error(
|
|
78
|
+
"queryMappings: orderBy.direction must be 'asc' or 'desc'"
|
|
79
|
+
);
|
|
80
|
+
}
|
|
81
|
+
return { path: segments, direction: orderBy.direction };
|
|
82
|
+
}
|
|
83
|
+
|
|
84
|
+
function toWhereEntry(entry) {
|
|
85
|
+
assertWhereEntryShape(entry);
|
|
86
|
+
if (!('anyOf' in entry)) return toCondition(entry);
|
|
87
|
+
|
|
88
|
+
const { anyOf } = entry;
|
|
89
|
+
if (!Array.isArray(anyOf) || anyOf.length === 0) {
|
|
90
|
+
throw new Error('queryMappings: anyOf must be a non-empty array');
|
|
91
|
+
}
|
|
92
|
+
return {
|
|
93
|
+
anyOf: anyOf.map((condition) => {
|
|
94
|
+
assertWhereEntryShape(condition);
|
|
95
|
+
if ('anyOf' in condition) {
|
|
96
|
+
throw new Error('queryMappings: nested anyOf is not supported');
|
|
97
|
+
}
|
|
98
|
+
return toCondition(condition);
|
|
99
|
+
}),
|
|
100
|
+
};
|
|
101
|
+
}
|
|
102
|
+
|
|
103
|
+
function assertWhereEntryShape(entry) {
|
|
104
|
+
if (!isPlainObject(entry)) {
|
|
105
|
+
throw new Error('queryMappings: each where entry must be an object');
|
|
106
|
+
}
|
|
107
|
+
}
|
|
108
|
+
|
|
109
|
+
function isPlainObject(value) {
|
|
110
|
+
return value !== null && typeof value === 'object' && !Array.isArray(value);
|
|
111
|
+
}
|
|
112
|
+
|
|
113
|
+
/**
|
|
114
|
+
* `{ path: 'mapping.outbound.status', op: 'in', value: ['failed'] }` →
|
|
115
|
+
* `{ field: 'mapping', path: ['outbound', 'status'], op: 'in', value: ['failed'] }`.
|
|
116
|
+
* A `sourceId` condition has no `path`; an op without a value has no `value`.
|
|
117
|
+
*/
|
|
118
|
+
function toCondition({ path, op, value }) {
|
|
119
|
+
const { field, segments } = parsePath(path);
|
|
120
|
+
const operator = Object.hasOwn(OPERATORS, op) ? OPERATORS[op] : null;
|
|
121
|
+
if (!operator?.fields.includes(field)) {
|
|
122
|
+
throw new Error(
|
|
123
|
+
`queryMappings: op ${JSON.stringify(
|
|
124
|
+
op
|
|
125
|
+
)} is not allowed on '${path}' (allowed: ${operatorsOn(field).join(
|
|
126
|
+
', '
|
|
127
|
+
)})`
|
|
128
|
+
);
|
|
129
|
+
}
|
|
130
|
+
return {
|
|
131
|
+
field,
|
|
132
|
+
...(segments.length > 0 && { path: segments }),
|
|
133
|
+
op,
|
|
134
|
+
...(operator.value && { value: operator.value(value, path) }),
|
|
135
|
+
};
|
|
136
|
+
}
|
|
137
|
+
|
|
138
|
+
function operatorsOn(field) {
|
|
139
|
+
return Object.keys(OPERATORS).filter((op) =>
|
|
140
|
+
OPERATORS[op].fields.includes(field)
|
|
141
|
+
);
|
|
142
|
+
}
|
|
143
|
+
|
|
144
|
+
function toStringList(value, path) {
|
|
145
|
+
if (
|
|
146
|
+
!Array.isArray(value) ||
|
|
147
|
+
value.length === 0 ||
|
|
148
|
+
!value.every((v) => typeof v === 'string')
|
|
149
|
+
) {
|
|
150
|
+
throw new Error(
|
|
151
|
+
`queryMappings: 'in' value must be a non-empty array of strings on '${path}'`
|
|
152
|
+
);
|
|
153
|
+
}
|
|
154
|
+
if (value.length > MAX_IN_VALUES) {
|
|
155
|
+
throw new Error(
|
|
156
|
+
`queryMappings: 'in' value must have at most ${MAX_IN_VALUES} strings on '${path}'`
|
|
157
|
+
);
|
|
158
|
+
}
|
|
159
|
+
return value;
|
|
160
|
+
}
|
|
161
|
+
|
|
162
|
+
function toPrefix(value, path) {
|
|
163
|
+
if (typeof value !== 'string' || value.length === 0) {
|
|
164
|
+
throw new Error(
|
|
165
|
+
`queryMappings: 'notStartsWith' value must be a non-empty string on '${path}'`
|
|
166
|
+
);
|
|
167
|
+
}
|
|
168
|
+
return value;
|
|
169
|
+
}
|
|
170
|
+
|
|
171
|
+
/**
|
|
172
|
+
* `'mapping.outbound.status'` → `{ field: 'mapping', segments: ['outbound', 'status'] }`,
|
|
173
|
+
* `'sourceId'` → `{ field: 'sourceId', segments: [] }`.
|
|
174
|
+
*/
|
|
175
|
+
function parsePath(path) {
|
|
176
|
+
const [field, ...segments] =
|
|
177
|
+
typeof path === 'string' ? path.split('.') : [];
|
|
178
|
+
const valid =
|
|
179
|
+
(field === 'sourceId' && segments.length === 0) ||
|
|
180
|
+
(field === 'mapping' &&
|
|
181
|
+
segments.length > 0 &&
|
|
182
|
+
segments.every((segment) => SEGMENT_REGEX.test(segment)));
|
|
183
|
+
if (!valid) {
|
|
184
|
+
throw new Error(
|
|
185
|
+
`queryMappings: invalid path ${JSON.stringify(
|
|
186
|
+
path
|
|
187
|
+
)} (must be 'sourceId' or 'mapping.<segment>...' with segments matching ${SEGMENT_REGEX})`
|
|
188
|
+
);
|
|
189
|
+
}
|
|
190
|
+
return { field, segments };
|
|
191
|
+
}
|
|
192
|
+
|
|
193
|
+
module.exports = { validateMappingQuery };
|
|
@@ -8,6 +8,7 @@ const {
|
|
|
8
8
|
updateOne,
|
|
9
9
|
deleteOne,
|
|
10
10
|
deleteMany,
|
|
11
|
+
aggregate,
|
|
11
12
|
aggregateDrained,
|
|
12
13
|
} = require('../../database/documentdb-utils');
|
|
13
14
|
const {
|
|
@@ -16,6 +17,20 @@ const {
|
|
|
16
17
|
const {
|
|
17
18
|
DocumentDBEncryptionService,
|
|
18
19
|
} = require('../../database/documentdb-encryption-service');
|
|
20
|
+
const {
|
|
21
|
+
assertMappingWrittenUnencrypted,
|
|
22
|
+
} = require('../../database/encryption/integration-mapping-encryption');
|
|
23
|
+
const { validateMappingQuery } = require('./integration-mapping-query');
|
|
24
|
+
const {
|
|
25
|
+
buildMappingQueryStages,
|
|
26
|
+
} = require('./integration-mapping-query-pipeline');
|
|
27
|
+
|
|
28
|
+
function storedIntegrationId(id) {
|
|
29
|
+
if (!['string', 'number'].includes(typeof id) || id === '') {
|
|
30
|
+
throw new TypeError(`Invalid ID: ${id}`);
|
|
31
|
+
}
|
|
32
|
+
return String(id);
|
|
33
|
+
}
|
|
19
34
|
|
|
20
35
|
class IntegrationMappingRepositoryDocumentDB extends IntegrationMappingRepositoryInterface {
|
|
21
36
|
constructor() {
|
|
@@ -179,6 +194,44 @@ class IntegrationMappingRepositoryDocumentDB extends IntegrationMappingRepositor
|
|
|
179
194
|
return decryptedDocs.map((doc) => this._mapMapping(doc));
|
|
180
195
|
}
|
|
181
196
|
|
|
197
|
+
/**
|
|
198
|
+
* @param {string} integrationId
|
|
199
|
+
* @param {Object} query - See IntegrationMappingRepositoryInterface.queryMappings
|
|
200
|
+
* @returns {Promise<{mappings: Array<Object>, total: number}>}
|
|
201
|
+
*/
|
|
202
|
+
async queryMappings(integrationId, query) {
|
|
203
|
+
const validated = validateMappingQuery(query);
|
|
204
|
+
const stored = storedIntegrationId(integrationId);
|
|
205
|
+
assertMappingWrittenUnencrypted();
|
|
206
|
+
const { match, page, sort } = buildMappingQueryStages(
|
|
207
|
+
stored,
|
|
208
|
+
validated
|
|
209
|
+
);
|
|
210
|
+
|
|
211
|
+
const [docs, counts] = await Promise.all([
|
|
212
|
+
aggregateDrained(
|
|
213
|
+
this.prisma,
|
|
214
|
+
'IntegrationMapping',
|
|
215
|
+
[match, ...page, sort],
|
|
216
|
+
{ allowDiskUse: true }
|
|
217
|
+
),
|
|
218
|
+
aggregate(this.prisma, 'IntegrationMapping', [
|
|
219
|
+
match,
|
|
220
|
+
{ $count: 'total' },
|
|
221
|
+
]),
|
|
222
|
+
]);
|
|
223
|
+
const decryptedDocs = await Promise.all(
|
|
224
|
+
docs.map((doc) =>
|
|
225
|
+
this.encryptionService.decryptFields('IntegrationMapping', doc)
|
|
226
|
+
)
|
|
227
|
+
);
|
|
228
|
+
|
|
229
|
+
return {
|
|
230
|
+
mappings: decryptedDocs.map((doc) => this._mapMapping(doc)),
|
|
231
|
+
total: counts[0]?.total ?? 0,
|
|
232
|
+
};
|
|
233
|
+
}
|
|
234
|
+
|
|
182
235
|
async deleteMapping(integrationId, sourceId) {
|
|
183
236
|
const filter = this._compositeFilter(integrationId, sourceId);
|
|
184
237
|
const result = await deleteOne(
|
|
@@ -52,6 +52,54 @@ class IntegrationMappingRepositoryInterface {
|
|
|
52
52
|
);
|
|
53
53
|
}
|
|
54
54
|
|
|
55
|
+
/**
|
|
56
|
+
* Query one filtered, ordered page of an integration's mappings without
|
|
57
|
+
* loading every row. Rows have the same shape as findMappingsByIntegration
|
|
58
|
+
* and are decrypted the same way.
|
|
59
|
+
*
|
|
60
|
+
* Paths address the `mapping` JSON by identifier-only segments
|
|
61
|
+
* (`'mapping.outbound.status'`), or the `sourceId` column. Conditions:
|
|
62
|
+
* - `{ path: 'mapping.…', op: 'exists' | 'notExists' }` — JSON null counts
|
|
63
|
+
* as absent; notExists is the exact negation of exists.
|
|
64
|
+
* - `{ path: 'mapping.…', op: 'in', value: string[] }` — matches JSON
|
|
65
|
+
* strings; 1–500 values.
|
|
66
|
+
* - `{ path: 'sourceId', op: 'notStartsWith', value: string }` — a NULL
|
|
67
|
+
* sourceId matches.
|
|
68
|
+
*
|
|
69
|
+
* Only rows whose `mapping` is a JSON object can match, so rows whose
|
|
70
|
+
* whole `mapping` is still ciphertext from before an encryption opt-out
|
|
71
|
+
* never do. A nested path still encrypted from before its opt-out comes
|
|
72
|
+
* back plain, but conditions and orderBy on it see the ciphertext.
|
|
73
|
+
* Adapters refuse to run while field-level encryption is enabled
|
|
74
|
+
* and still encrypts `mapping`, or a path inside it, on write; opt out with
|
|
75
|
+
* `appDefinition.encryption.disable = { IntegrationMapping: ['mapping'] }`
|
|
76
|
+
* plus any nested `mapping.…` path a custom schema encrypts.
|
|
77
|
+
*
|
|
78
|
+
* @param {string|number} integrationId - The integration ID
|
|
79
|
+
* @param {Object} query
|
|
80
|
+
* @param {Array<Object>} [query.where=[]] - Conditions ANDed together; an
|
|
81
|
+
* entry may be `{ anyOf: Condition[] }` (one level, ORed). At most 20
|
|
82
|
+
* conditions, anyOf members included.
|
|
83
|
+
* @param {{path: string, direction: 'asc'|'desc'}} [query.orderBy] - A
|
|
84
|
+
* mapping path; nulls last, ties broken by id in the same direction.
|
|
85
|
+
* Values order string < number < boolean < array < object. Strings
|
|
86
|
+
* compare by the database collation on PostgreSQL and by code point on
|
|
87
|
+
* MongoDB and DocumentDB; arrays and objects order among themselves
|
|
88
|
+
* only on PostgreSQL. Without it rows are ordered by id ascending.
|
|
89
|
+
* @param {number} [query.skip=0] - Rows to skip (integer ≥ 0)
|
|
90
|
+
* @param {number} query.take - Page size (integer 1–500)
|
|
91
|
+
* @param {string[]} [query.omit=[]] - Top-level mapping keys to leave out of
|
|
92
|
+
* the returned rows; such projected rows must not be written back
|
|
93
|
+
* @returns {Promise<{mappings: Array<Object>, total: number}>} The page, and
|
|
94
|
+
* the number of rows matching `where` (counted by a separate command on
|
|
95
|
+
* DocumentDB, so not from the page's snapshot)
|
|
96
|
+
*/
|
|
97
|
+
async queryMappings(integrationId, query) {
|
|
98
|
+
throw new Error(
|
|
99
|
+
'queryMappings is not supported by this database adapter yet'
|
|
100
|
+
);
|
|
101
|
+
}
|
|
102
|
+
|
|
55
103
|
/**
|
|
56
104
|
* Delete a specific mapping
|
|
57
105
|
*
|
|
@@ -1,7 +1,26 @@
|
|
|
1
1
|
const { prisma } = require('../../database/prisma');
|
|
2
|
+
const {
|
|
3
|
+
assertMappingWrittenUnencrypted,
|
|
4
|
+
decryptQueriedMappings,
|
|
5
|
+
} = require('../../database/encryption/integration-mapping-encryption');
|
|
2
6
|
const {
|
|
3
7
|
IntegrationMappingRepositoryInterface,
|
|
4
8
|
} = require('./integration-mapping-repository-interface');
|
|
9
|
+
const { validateMappingQuery } = require('./integration-mapping-query');
|
|
10
|
+
const {
|
|
11
|
+
buildMappingQueryStages,
|
|
12
|
+
} = require('./integration-mapping-query-pipeline');
|
|
13
|
+
|
|
14
|
+
const OBJECT_ID_REGEX = /^[0-9a-fA-F]{24}$/;
|
|
15
|
+
|
|
16
|
+
const fromRawDate = (raw) => new Date(raw.$date);
|
|
17
|
+
|
|
18
|
+
function strictObjectId(id) {
|
|
19
|
+
if (typeof id !== 'string' || !OBJECT_ID_REGEX.test(id)) {
|
|
20
|
+
throw new TypeError(`Invalid ID: ${id} is not an ObjectId`);
|
|
21
|
+
}
|
|
22
|
+
return id;
|
|
23
|
+
}
|
|
5
24
|
|
|
6
25
|
/**
|
|
7
26
|
* MongoDB Integration Mapping Repository Adapter
|
|
@@ -155,6 +174,59 @@ class IntegrationMappingRepositoryMongo extends IntegrationMappingRepositoryInte
|
|
|
155
174
|
return counts;
|
|
156
175
|
}
|
|
157
176
|
|
|
177
|
+
/**
|
|
178
|
+
* @param {string} integrationId
|
|
179
|
+
* @param {Object} query - See IntegrationMappingRepositoryInterface.queryMappings
|
|
180
|
+
* @returns {Promise<{mappings: Array<Object>, total: number}>}
|
|
181
|
+
*/
|
|
182
|
+
async queryMappings(integrationId, query) {
|
|
183
|
+
const validated = validateMappingQuery(query);
|
|
184
|
+
const objectId = strictObjectId(integrationId);
|
|
185
|
+
assertMappingWrittenUnencrypted();
|
|
186
|
+
const { match, page } = buildMappingQueryStages(
|
|
187
|
+
{ $oid: objectId },
|
|
188
|
+
validated
|
|
189
|
+
);
|
|
190
|
+
|
|
191
|
+
const result = await this.prisma.$runCommandRaw({
|
|
192
|
+
aggregate: 'IntegrationMapping',
|
|
193
|
+
pipeline: [
|
|
194
|
+
match,
|
|
195
|
+
{
|
|
196
|
+
$facet: {
|
|
197
|
+
mappings: page,
|
|
198
|
+
total: [{ $count: 'total' }],
|
|
199
|
+
},
|
|
200
|
+
},
|
|
201
|
+
],
|
|
202
|
+
cursor: {},
|
|
203
|
+
allowDiskUse: true,
|
|
204
|
+
});
|
|
205
|
+
const [{ mappings, total }] = result.cursor.firstBatch;
|
|
206
|
+
|
|
207
|
+
return {
|
|
208
|
+
mappings: await decryptQueriedMappings(
|
|
209
|
+
mappings.map((doc) => this._fromRawMapping(doc))
|
|
210
|
+
),
|
|
211
|
+
total: total[0]?.total ?? 0,
|
|
212
|
+
};
|
|
213
|
+
}
|
|
214
|
+
|
|
215
|
+
/**
|
|
216
|
+
* A raw aggregate document, in the shape findMappingsByIntegration returns.
|
|
217
|
+
* @private
|
|
218
|
+
*/
|
|
219
|
+
_fromRawMapping(doc) {
|
|
220
|
+
return {
|
|
221
|
+
id: doc._id.$oid,
|
|
222
|
+
integrationId: doc.integrationId.$oid,
|
|
223
|
+
sourceId: doc.sourceId ?? null,
|
|
224
|
+
mapping: doc.mapping ?? null,
|
|
225
|
+
createdAt: fromRawDate(doc.createdAt),
|
|
226
|
+
updatedAt: fromRawDate(doc.updatedAt),
|
|
227
|
+
};
|
|
228
|
+
}
|
|
229
|
+
|
|
158
230
|
/**
|
|
159
231
|
* Find mapping by ID
|
|
160
232
|
* @param {string} id - Mapping ID
|