@cerbos/orm-prisma 0.1.1 → 0.1.2

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.
Files changed (7) hide show
  1. package/lib/cjs/index.js +20 -14
  2. package/lib/cjs/index.test.d.ts +1 -0
  3. package/lib/cjs/index.test.js +311 -0
  4. package/lib/index.js +20 -14
  5. package/lib/index.test.d.ts +1 -0
  6. package/lib/index.test.js +306 -0
  7. package/package.json +6 -3
package/lib/cjs/index.js CHANGED
@@ -25,6 +25,12 @@ function isValue(e) {
25
25
  function isVariable(e) {
26
26
  return e.variable !== undefined;
27
27
  }
28
+ function getOperandName(operands) {
29
+ return (operands.find(o => o.hasOwnProperty("name"))).name;
30
+ }
31
+ function getOperandValue(operands) {
32
+ return (operands.find(o => o.hasOwnProperty("value"))).value;
33
+ }
28
34
  function mapOperand(operand, getFieldName, output = {}) {
29
35
  if (isExpression(operand)) {
30
36
  const { operator, operands } = operand;
@@ -36,38 +42,38 @@ function mapOperand(operand, getFieldName, output = {}) {
36
42
  output.OR = operands.map((o) => mapOperand(o, getFieldName, {}));
37
43
  break;
38
44
  case "eq":
39
- output[getFieldName(operands[0].name)] = {
40
- equals: operands[1].value,
45
+ output[getFieldName(getOperandName(operands))] = {
46
+ equals: getOperandValue(operands),
41
47
  };
42
48
  break;
43
49
  case "ne":
44
- output[getFieldName(operands[0].name)] = {
45
- not: operands[1].value,
50
+ output[getFieldName(getOperandName(operands))] = {
51
+ not: getOperandValue(operands),
46
52
  };
47
53
  break;
48
54
  case "lt":
49
- output[getFieldName(operands[0].name)] = {
50
- lt: operands[1].value,
55
+ output[getFieldName(getOperandName(operands))] = {
56
+ lt: getOperandValue(operands),
51
57
  };
52
58
  break;
53
59
  case "gt":
54
- output[getFieldName(operands[0].name)] = {
55
- gt: operands[1].value,
60
+ output[getFieldName(getOperandName(operands))] = {
61
+ gt: getOperandValue(operands),
56
62
  };
57
63
  break;
58
64
  case "lte":
59
- output[getFieldName(operands[0].name)] = {
60
- lte: operands[1].value,
65
+ output[getFieldName(getOperandName(operands))] = {
66
+ lte: getOperandValue(operands),
61
67
  };
62
68
  break;
63
69
  case "gte":
64
- output[getFieldName(operands[0].name)] = {
65
- gte: operands[1].value,
70
+ output[getFieldName(getOperandName(operands))] = {
71
+ gte: getOperandValue(operands),
66
72
  };
67
73
  break;
68
74
  case "in":
69
- output[getFieldName(operands[0].name)] = {
70
- in: operands[1].value,
75
+ output[getFieldName(getOperandName(operands))] = {
76
+ in: getOperandValue(operands),
71
77
  };
72
78
  break;
73
79
  }
package/lib/cjs/index.test.d.ts ADDED
@@ -0,0 +1 @@
1
+ export {};
package/lib/cjs/index.test.js ADDED
@@ -0,0 +1,311 @@
1
+ "use strict";
2
+ var __importDefault = (this && this.__importDefault) || function (mod) {
3
+ return (mod && mod.__esModule) ? mod : { "default": mod };
4
+ };
5
+ Object.defineProperty(exports, "__esModule", { value: true });
6
+ const _1 = __importDefault(require("."));
7
+ const core_1 = require("@cerbos/core");
8
+ test("always allowed", () => {
9
+ const queryPlan = {
10
+ requestId: "",
11
+ metadata: undefined,
12
+ kind: core_1.PlanKind.ALWAYS_ALLOWED,
13
+ };
14
+ const result = (0, _1.default)({
15
+ queryPlan,
16
+ fieldNameMapper: {
17
+ "request.resource.attr.ownerId": "ownerId",
18
+ },
19
+ });
20
+ expect(result).toStrictEqual({});
21
+ });
22
+ test("always denied", () => {
23
+ const queryPlan = {
24
+ requestId: "",
25
+ metadata: undefined,
26
+ kind: core_1.PlanKind.ALWAYS_DENIED,
27
+ };
28
+ const result = (0, _1.default)({
29
+ queryPlan,
30
+ fieldNameMapper: {
31
+ "request.resource.attr.ownerId": "ownerId",
32
+ },
33
+ });
34
+ expect(result).toStrictEqual({ "1": { "equals": 0 } });
35
+ });
36
+ test("conditional - eq", () => {
37
+ const queryPlan = {
38
+ requestId: "",
39
+ metadata: undefined,
40
+ kind: core_1.PlanKind.CONDITIONAL,
41
+ condition: {
42
+ operator: "eq",
43
+ operands: [{ name: "request.resource.attr.ownerId" }, { value: "sally" }],
44
+ },
45
+ };
46
+ const result = (0, _1.default)({
47
+ queryPlan,
48
+ fieldNameMapper: {
49
+ "request.resource.attr.ownerId": "ownerId",
50
+ },
51
+ });
52
+ expect(result).toStrictEqual({ ownerId: { equals: "sally" } });
53
+ });
54
+ test("conditional - eq - inverted order", () => {
55
+ const queryPlan = {
56
+ requestId: "",
57
+ metadata: undefined,
58
+ kind: core_1.PlanKind.CONDITIONAL,
59
+ condition: {
60
+ operator: "eq",
61
+ operands: [
62
+ { value: "sally" },
63
+ { name: "request.resource.attr.ownerId" }
64
+ ],
65
+ },
66
+ };
67
+ const result = (0, _1.default)({
68
+ queryPlan,
69
+ fieldNameMapper: {
70
+ "request.resource.attr.ownerId": "ownerId",
71
+ },
72
+ });
73
+ expect(result).toStrictEqual({ ownerId: { equals: "sally" } });
74
+ });
75
+ test("conditional - and", () => {
76
+ const queryPlan = {
77
+ requestId: "",
78
+ metadata: undefined,
79
+ kind: core_1.PlanKind.CONDITIONAL,
80
+ condition: {
81
+ "operator": "and",
82
+ "operands": [
83
+ {
84
+ "operator": "eq",
85
+ "operands": [
86
+ {
87
+ "name": "request.resource.attr.department"
88
+ },
89
+ {
90
+ "value": "marketing"
91
+ }
92
+ ]
93
+ },
94
+ {
95
+ "operator": "ne",
96
+ "operands": [
97
+ {
98
+ "name": "request.resource.attr.team"
99
+ },
100
+ {
101
+ "value": "design"
102
+ }
103
+ ]
104
+ }
105
+ ]
106
+ },
107
+ };
108
+ const result = (0, _1.default)({
109
+ queryPlan,
110
+ fieldNameMapper: {
111
+ "request.resource.attr.department": "department",
112
+ "request.resource.attr.team": "team",
113
+ },
114
+ });
115
+ expect(result).toStrictEqual({
116
+ AND: [
117
+ {
118
+ department: { equals: "marketing" }
119
+ },
120
+ {
121
+ team: { not: "design" }
122
+ }
123
+ ]
124
+ });
125
+ });
126
+ test("conditional - or", () => {
127
+ const queryPlan = {
128
+ requestId: "",
129
+ metadata: undefined,
130
+ kind: core_1.PlanKind.CONDITIONAL,
131
+ condition: {
132
+ "operator": "or",
133
+ "operands": [
134
+ {
135
+ "operator": "eq",
136
+ "operands": [
137
+ {
138
+ "name": "request.resource.attr.department"
139
+ },
140
+ {
141
+ "value": "marketing"
142
+ }
143
+ ]
144
+ },
145
+ {
146
+ "operator": "ne",
147
+ "operands": [
148
+ {
149
+ "name": "request.resource.attr.team"
150
+ },
151
+ {
152
+ "value": "design"
153
+ }
154
+ ]
155
+ }
156
+ ]
157
+ },
158
+ };
159
+ const result = (0, _1.default)({
160
+ queryPlan,
161
+ fieldNameMapper: {
162
+ "request.resource.attr.department": "department",
163
+ "request.resource.attr.team": "team",
164
+ },
165
+ });
166
+ expect(result).toStrictEqual({
167
+ OR: [
168
+ {
169
+ department: { equals: "marketing" }
170
+ },
171
+ {
172
+ team: { not: "design" }
173
+ }
174
+ ]
175
+ });
176
+ });
177
+ test("conditional - in", () => {
178
+ const queryPlan = {
179
+ requestId: "",
180
+ metadata: undefined,
181
+ kind: core_1.PlanKind.CONDITIONAL,
182
+ condition: {
183
+ "operator": "in",
184
+ "operands": [
185
+ {
186
+ "name": "request.resource.attr.department"
187
+ },
188
+ {
189
+ "value": ["marketing", "design"]
190
+ }
191
+ ]
192
+ },
193
+ };
194
+ const result = (0, _1.default)({
195
+ queryPlan,
196
+ fieldNameMapper: {
197
+ "request.resource.attr.department": "department",
198
+ },
199
+ });
200
+ expect(result).toStrictEqual({
201
+ department: { in: ["marketing", "design"] }
202
+ });
203
+ });
204
+ test("conditional - gt", () => {
205
+ const queryPlan = {
206
+ requestId: "",
207
+ metadata: undefined,
208
+ kind: core_1.PlanKind.CONDITIONAL,
209
+ condition: {
210
+ "operator": "gt",
211
+ "operands": [
212
+ {
213
+ "name": "request.resource.attr.amount"
214
+ },
215
+ {
216
+ "value": 1000
217
+ }
218
+ ]
219
+ },
220
+ };
221
+ const result = (0, _1.default)({
222
+ queryPlan,
223
+ fieldNameMapper: {
224
+ "request.resource.attr.amount": "amount",
225
+ },
226
+ });
227
+ expect(result).toStrictEqual({
228
+ amount: { gt: 1000 }
229
+ });
230
+ });
231
+ test("conditional - lt", () => {
232
+ const queryPlan = {
233
+ requestId: "",
234
+ metadata: undefined,
235
+ kind: core_1.PlanKind.CONDITIONAL,
236
+ condition: {
237
+ "operator": "lt",
238
+ "operands": [
239
+ {
240
+ "name": "request.resource.attr.amount"
241
+ },
242
+ {
243
+ "value": 1000
244
+ }
245
+ ]
246
+ },
247
+ };
248
+ const result = (0, _1.default)({
249
+ queryPlan,
250
+ fieldNameMapper: {
251
+ "request.resource.attr.amount": "amount",
252
+ },
253
+ });
254
+ expect(result).toStrictEqual({
255
+ amount: { lt: 1000 }
256
+ });
257
+ });
258
+ test("conditional - gte", () => {
259
+ const queryPlan = {
260
+ requestId: "",
261
+ metadata: undefined,
262
+ kind: core_1.PlanKind.CONDITIONAL,
263
+ condition: {
264
+ "operator": "gte",
265
+ "operands": [
266
+ {
267
+ "name": "request.resource.attr.amount"
268
+ },
269
+ {
270
+ "value": 1000
271
+ }
272
+ ]
273
+ },
274
+ };
275
+ const result = (0, _1.default)({
276
+ queryPlan,
277
+ fieldNameMapper: {
278
+ "request.resource.attr.amount": "amount",
279
+ },
280
+ });
281
+ expect(result).toStrictEqual({
282
+ amount: { gte: 1000 }
283
+ });
284
+ });
285
+ test("conditional - lte", () => {
286
+ const queryPlan = {
287
+ requestId: "",
288
+ metadata: undefined,
289
+ kind: core_1.PlanKind.CONDITIONAL,
290
+ condition: {
291
+ "operator": "lte",
292
+ "operands": [
293
+ {
294
+ "name": "request.resource.attr.amount"
295
+ },
296
+ {
297
+ "value": 1000
298
+ }
299
+ ]
300
+ },
301
+ };
302
+ const result = (0, _1.default)({
303
+ queryPlan,
304
+ fieldNameMapper: {
305
+ "request.resource.attr.amount": "amount",
306
+ },
307
+ });
308
+ expect(result).toStrictEqual({
309
+ amount: { lte: 1000 }
310
+ });
311
+ });
package/lib/index.js CHANGED
@@ -22,6 +22,12 @@ function isValue(e) {
22
22
  function isVariable(e) {
23
23
  return e.variable !== undefined;
24
24
  }
25
+ function getOperandName(operands) {
26
+ return (operands.find(o => o.hasOwnProperty("name"))).name;
27
+ }
28
+ function getOperandValue(operands) {
29
+ return (operands.find(o => o.hasOwnProperty("value"))).value;
30
+ }
25
31
  function mapOperand(operand, getFieldName, output = {}) {
26
32
  if (isExpression(operand)) {
27
33
  const { operator, operands } = operand;
@@ -33,38 +39,38 @@ function mapOperand(operand, getFieldName, output = {}) {
33
39
  output.OR = operands.map((o) => mapOperand(o, getFieldName, {}));
34
40
  break;
35
41
  case "eq":
36
- output[getFieldName(operands[0].name)] = {
37
- equals: operands[1].value,
42
+ output[getFieldName(getOperandName(operands))] = {
43
+ equals: getOperandValue(operands),
38
44
  };
39
45
  break;
40
46
  case "ne":
41
- output[getFieldName(operands[0].name)] = {
42
- not: operands[1].value,
47
+ output[getFieldName(getOperandName(operands))] = {
48
+ not: getOperandValue(operands),
43
49
  };
44
50
  break;
45
51
  case "lt":
46
- output[getFieldName(operands[0].name)] = {
47
- lt: operands[1].value,
52
+ output[getFieldName(getOperandName(operands))] = {
53
+ lt: getOperandValue(operands),
48
54
  };
49
55
  break;
50
56
  case "gt":
51
- output[getFieldName(operands[0].name)] = {
52
- gt: operands[1].value,
57
+ output[getFieldName(getOperandName(operands))] = {
58
+ gt: getOperandValue(operands),
53
59
  };
54
60
  break;
55
61
  case "lte":
56
- output[getFieldName(operands[0].name)] = {
57
- lte: operands[1].value,
62
+ output[getFieldName(getOperandName(operands))] = {
63
+ lte: getOperandValue(operands),
58
64
  };
59
65
  break;
60
66
  case "gte":
61
- output[getFieldName(operands[0].name)] = {
62
- gte: operands[1].value,
67
+ output[getFieldName(getOperandName(operands))] = {
68
+ gte: getOperandValue(operands),
63
69
  };
64
70
  break;
65
71
  case "in":
66
- output[getFieldName(operands[0].name)] = {
67
- in: operands[1].value,
72
+ output[getFieldName(getOperandName(operands))] = {
73
+ in: getOperandValue(operands),
68
74
  };
69
75
  break;
70
76
  }
package/lib/index.test.d.ts ADDED
@@ -0,0 +1 @@
1
+ export {};
package/lib/index.test.js ADDED
@@ -0,0 +1,306 @@
1
+ import queryPlanToPrisma from ".";
2
+ import { PlanKind } from "@cerbos/core";
3
+ test("always allowed", () => {
4
+ const queryPlan = {
5
+ requestId: "",
6
+ metadata: undefined,
7
+ kind: PlanKind.ALWAYS_ALLOWED,
8
+ };
9
+ const result = queryPlanToPrisma({
10
+ queryPlan,
11
+ fieldNameMapper: {
12
+ "request.resource.attr.ownerId": "ownerId",
13
+ },
14
+ });
15
+ expect(result).toStrictEqual({});
16
+ });
17
+ test("always denied", () => {
18
+ const queryPlan = {
19
+ requestId: "",
20
+ metadata: undefined,
21
+ kind: PlanKind.ALWAYS_DENIED,
22
+ };
23
+ const result = queryPlanToPrisma({
24
+ queryPlan,
25
+ fieldNameMapper: {
26
+ "request.resource.attr.ownerId": "ownerId",
27
+ },
28
+ });
29
+ expect(result).toStrictEqual({ "1": { "equals": 0 } });
30
+ });
31
+ test("conditional - eq", () => {
32
+ const queryPlan = {
33
+ requestId: "",
34
+ metadata: undefined,
35
+ kind: PlanKind.CONDITIONAL,
36
+ condition: {
37
+ operator: "eq",
38
+ operands: [{ name: "request.resource.attr.ownerId" }, { value: "sally" }],
39
+ },
40
+ };
41
+ const result = queryPlanToPrisma({
42
+ queryPlan,
43
+ fieldNameMapper: {
44
+ "request.resource.attr.ownerId": "ownerId",
45
+ },
46
+ });
47
+ expect(result).toStrictEqual({ ownerId: { equals: "sally" } });
48
+ });
49
+ test("conditional - eq - inverted order", () => {
50
+ const queryPlan = {
51
+ requestId: "",
52
+ metadata: undefined,
53
+ kind: PlanKind.CONDITIONAL,
54
+ condition: {
55
+ operator: "eq",
56
+ operands: [
57
+ { value: "sally" },
58
+ { name: "request.resource.attr.ownerId" }
59
+ ],
60
+ },
61
+ };
62
+ const result = queryPlanToPrisma({
63
+ queryPlan,
64
+ fieldNameMapper: {
65
+ "request.resource.attr.ownerId": "ownerId",
66
+ },
67
+ });
68
+ expect(result).toStrictEqual({ ownerId: { equals: "sally" } });
69
+ });
70
+ test("conditional - and", () => {
71
+ const queryPlan = {
72
+ requestId: "",
73
+ metadata: undefined,
74
+ kind: PlanKind.CONDITIONAL,
75
+ condition: {
76
+ "operator": "and",
77
+ "operands": [
78
+ {
79
+ "operator": "eq",
80
+ "operands": [
81
+ {
82
+ "name": "request.resource.attr.department"
83
+ },
84
+ {
85
+ "value": "marketing"
86
+ }
87
+ ]
88
+ },
89
+ {
90
+ "operator": "ne",
91
+ "operands": [
92
+ {
93
+ "name": "request.resource.attr.team"
94
+ },
95
+ {
96
+ "value": "design"
97
+ }
98
+ ]
99
+ }
100
+ ]
101
+ },
102
+ };
103
+ const result = queryPlanToPrisma({
104
+ queryPlan,
105
+ fieldNameMapper: {
106
+ "request.resource.attr.department": "department",
107
+ "request.resource.attr.team": "team",
108
+ },
109
+ });
110
+ expect(result).toStrictEqual({
111
+ AND: [
112
+ {
113
+ department: { equals: "marketing" }
114
+ },
115
+ {
116
+ team: { not: "design" }
117
+ }
118
+ ]
119
+ });
120
+ });
121
+ test("conditional - or", () => {
122
+ const queryPlan = {
123
+ requestId: "",
124
+ metadata: undefined,
125
+ kind: PlanKind.CONDITIONAL,
126
+ condition: {
127
+ "operator": "or",
128
+ "operands": [
129
+ {
130
+ "operator": "eq",
131
+ "operands": [
132
+ {
133
+ "name": "request.resource.attr.department"
134
+ },
135
+ {
136
+ "value": "marketing"
137
+ }
138
+ ]
139
+ },
140
+ {
141
+ "operator": "ne",
142
+ "operands": [
143
+ {
144
+ "name": "request.resource.attr.team"
145
+ },
146
+ {
147
+ "value": "design"
148
+ }
149
+ ]
150
+ }
151
+ ]
152
+ },
153
+ };
154
+ const result = queryPlanToPrisma({
155
+ queryPlan,
156
+ fieldNameMapper: {
157
+ "request.resource.attr.department": "department",
158
+ "request.resource.attr.team": "team",
159
+ },
160
+ });
161
+ expect(result).toStrictEqual({
162
+ OR: [
163
+ {
164
+ department: { equals: "marketing" }
165
+ },
166
+ {
167
+ team: { not: "design" }
168
+ }
169
+ ]
170
+ });
171
+ });
172
+ test("conditional - in", () => {
173
+ const queryPlan = {
174
+ requestId: "",
175
+ metadata: undefined,
176
+ kind: PlanKind.CONDITIONAL,
177
+ condition: {
178
+ "operator": "in",
179
+ "operands": [
180
+ {
181
+ "name": "request.resource.attr.department"
182
+ },
183
+ {
184
+ "value": ["marketing", "design"]
185
+ }
186
+ ]
187
+ },
188
+ };
189
+ const result = queryPlanToPrisma({
190
+ queryPlan,
191
+ fieldNameMapper: {
192
+ "request.resource.attr.department": "department",
193
+ },
194
+ });
195
+ expect(result).toStrictEqual({
196
+ department: { in: ["marketing", "design"] }
197
+ });
198
+ });
199
+ test("conditional - gt", () => {
200
+ const queryPlan = {
201
+ requestId: "",
202
+ metadata: undefined,
203
+ kind: PlanKind.CONDITIONAL,
204
+ condition: {
205
+ "operator": "gt",
206
+ "operands": [
207
+ {
208
+ "name": "request.resource.attr.amount"
209
+ },
210
+ {
211
+ "value": 1000
212
+ }
213
+ ]
214
+ },
215
+ };
216
+ const result = queryPlanToPrisma({
217
+ queryPlan,
218
+ fieldNameMapper: {
219
+ "request.resource.attr.amount": "amount",
220
+ },
221
+ });
222
+ expect(result).toStrictEqual({
223
+ amount: { gt: 1000 }
224
+ });
225
+ });
226
+ test("conditional - lt", () => {
227
+ const queryPlan = {
228
+ requestId: "",
229
+ metadata: undefined,
230
+ kind: PlanKind.CONDITIONAL,
231
+ condition: {
232
+ "operator": "lt",
233
+ "operands": [
234
+ {
235
+ "name": "request.resource.attr.amount"
236
+ },
237
+ {
238
+ "value": 1000
239
+ }
240
+ ]
241
+ },
242
+ };
243
+ const result = queryPlanToPrisma({
244
+ queryPlan,
245
+ fieldNameMapper: {
246
+ "request.resource.attr.amount": "amount",
247
+ },
248
+ });
249
+ expect(result).toStrictEqual({
250
+ amount: { lt: 1000 }
251
+ });
252
+ });
253
+ test("conditional - gte", () => {
254
+ const queryPlan = {
255
+ requestId: "",
256
+ metadata: undefined,
257
+ kind: PlanKind.CONDITIONAL,
258
+ condition: {
259
+ "operator": "gte",
260
+ "operands": [
261
+ {
262
+ "name": "request.resource.attr.amount"
263
+ },
264
+ {
265
+ "value": 1000
266
+ }
267
+ ]
268
+ },
269
+ };
270
+ const result = queryPlanToPrisma({
271
+ queryPlan,
272
+ fieldNameMapper: {
273
+ "request.resource.attr.amount": "amount",
274
+ },
275
+ });
276
+ expect(result).toStrictEqual({
277
+ amount: { gte: 1000 }
278
+ });
279
+ });
280
+ test("conditional - lte", () => {
281
+ const queryPlan = {
282
+ requestId: "",
283
+ metadata: undefined,
284
+ kind: PlanKind.CONDITIONAL,
285
+ condition: {
286
+ "operator": "lte",
287
+ "operands": [
288
+ {
289
+ "name": "request.resource.attr.amount"
290
+ },
291
+ {
292
+ "value": 1000
293
+ }
294
+ ]
295
+ },
296
+ };
297
+ const result = queryPlanToPrisma({
298
+ queryPlan,
299
+ fieldNameMapper: {
300
+ "request.resource.attr.amount": "amount",
301
+ },
302
+ });
303
+ expect(result).toStrictEqual({
304
+ amount: { lte: 1000 }
305
+ });
306
+ });
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "@cerbos/orm-prisma",
3
- "version": "0.1.1",
3
+ "version": "0.1.2",
4
4
  "homepage": "https://cerbos.dev",
5
5
  "description": "",
6
6
  "private": false,
@@ -14,15 +14,18 @@
14
14
  "prepare": "npm run build",
15
15
  "preversion": "npm run lint",
16
16
  "version": "git add -A src",
17
- "postversion": "git push && git push --tags"
17
+ "postversion": "git push && git push --tags",
18
+ "test": "jest src/**.test.ts"
18
19
  },
19
20
  "author": "Cerbos",
20
21
  "license": "Apache-2.0",
21
22
  "devDependencies": {
23
+ "@types/jest": "^29.0.0",
24
+ "ts-jest": "^28.0.8",
22
25
  "ts-node": "^10.4.0",
23
26
  "typescript": "^4.5.4"
24
27
  },
25
28
  "dependencies": {
26
- "@cerbos/core": "^0.5.0"
29
+ "@cerbos/core": "^0.5.1"
27
30
  }
28
31
  }