@workos-inc/node 7.29.1 → 7.30.1

package/lib/fga/fga.spec.js

@@ -16,6 +16,7 @@ const jest_fetch_mock_1 = __importDefault(require("jest-fetch-mock"));
 const test_utils_1 = require("../common/utils/test-utils");
 const workos_1 = require("../workos");
 const interfaces_1 = require("./interfaces");
+const exceptions_1 = require("../common/exceptions");
 const workos = new workos_1.WorkOS('sk_test_Sz3IQjepeSWaI4cMS4ms4sMuU');
 describe('FGA', () => {
     beforeEach(() => jest_fetch_mock_1.default.resetMocks());
@@ -46,6 +47,60 @@ describe('FGA', () => {
                 isImplicit: false,
             });
         }));
+        it('makes check request after one retry', () => __awaiter(void 0, void 0, void 0, function* () {
+            (0, test_utils_1.fetchOnce)({}, {
+                status: 500,
+            });
+            (0, test_utils_1.fetchOnce)({
+                result: 'authorized',
+                is_implicit: false,
+            });
+            const checkResult = yield workos.fga.check({
+                checks: [
+                    {
+                        resource: {
+                            resourceType: 'role',
+                            resourceId: 'admin',
+                        },
+                        relation: 'member',
+                        subject: {
+                            resourceType: 'user',
+                            resourceId: 'user_123',
+                        },
+                    },
+                ],
+            });
+            expect((0, test_utils_1.fetchURL)()).toContain('/fga/v1/check');
+            expect(checkResult).toMatchObject({
+                result: 'authorized',
+                isImplicit: false,
+            });
+        }));
+        it('fails check request after max retries', () => __awaiter(void 0, void 0, void 0, function* () {
+            jest_fetch_mock_1.default.mockResponse(JSON.stringify({
+                message: 'Internal Server Error',
+            }), { status: 500 });
+            try {
+                yield workos.fga.check({
+                    checks: [
+                        {
+                            resource: {
+                                resourceType: 'role',
+                                resourceId: 'admin',
+                            },
+                            relation: 'member',
+                            subject: {
+                                resourceType: 'user',
+                                resourceId: 'user_123',
+                            },
+                        },
+                    ],
+                });
+            }
+            catch (e) {
+                expect(e).toBeInstanceOf(exceptions_1.GenericServerException);
+            }
+        }), 8000);
     });
     describe('createResource', () => {
         it('creates resource', () => __awaiter(void 0, void 0, void 0, function* () {
@@ -65,6 +120,42 @@ describe('FGA', () => {
                 resourceId: 'admin',
             });
         }));
+        it('creates resource after one retry', () => __awaiter(void 0, void 0, void 0, function* () {
+            (0, test_utils_1.fetchOnce)({}, {
+                status: 502,
+            });
+            (0, test_utils_1.fetchOnce)({
+                resource_type: 'role',
+                resource_id: 'admin',
+            });
+            const resource = yield workos.fga.createResource({
+                resource: {
+                    resourceType: 'role',
+                    resourceId: 'admin',
+                },
+            });
+            expect((0, test_utils_1.fetchURL)()).toContain('/fga/v1/resources');
+            expect(resource).toMatchObject({
+                resourceType: 'role',
+                resourceId: 'admin',
+            });
+        }));
+        it('fails to creates resource after max retries', () => __awaiter(void 0, void 0, void 0, function* () {
+            jest_fetch_mock_1.default.mockResponse(JSON.stringify({
+                message: 'Internal Server Error',
+            }), { status: 500 });
+            try {
+                yield workos.fga.createResource({
+                    resource: {
+                        resourceType: 'role',
+                        resourceId: 'admin',
+                    },
+                });
+            }
+            catch (e) {
+                expect(e).toBeInstanceOf(exceptions_1.GenericServerException);
+            }
+        }), 8000);
         it('creates resource with metadata', () => __awaiter(void 0, void 0, void 0, function* () {
             (0, test_utils_1.fetchOnce)({
                 resource_type: 'role',
@@ -108,6 +199,38 @@ describe('FGA', () => {
                 resourceId: 'admin',
             });
         }));
+        it('gets resource after one retry', () => __awaiter(void 0, void 0, void 0, function* () {
+            (0, test_utils_1.fetchOnce)({}, {
+                status: 504,
+            });
+            (0, test_utils_1.fetchOnce)({
+                resource_type: 'role',
+                resource_id: 'admin',
+            });
+            const resource = yield workos.fga.getResource({
+                resourceType: 'role',
+                resourceId: 'admin',
+            });
+            expect((0, test_utils_1.fetchURL)()).toContain('/fga/v1/resources/role/admin');
+            expect(resource).toMatchObject({
+                resourceType: 'role',
+                resourceId: 'admin',
+            });
+        }));
+        it('fails to get resource after max retries', () => __awaiter(void 0, void 0, void 0, function* () {
+            jest_fetch_mock_1.default.mockResponse(JSON.stringify({
+                message: 'Internal Server Error',
+            }), { status: 500 });
+            try {
+                yield workos.fga.getResource({
+                    resourceType: 'role',
+                    resourceId: 'admin',
+                });
+            }
+            catch (e) {
+                expect(e).toBeInstanceOf(exceptions_1.GenericServerException);
+            }
+        }), 8000);
     });
     describe('listResources', () => {
         it('lists resources', () => __awaiter(void 0, void 0, void 0, function* () {
@@ -140,6 +263,53 @@ describe('FGA', () => {
                 },
             ]);
         }));
+        it('lists resources after two retries', () => __awaiter(void 0, void 0, void 0, function* () {
+            (0, test_utils_1.fetchOnce)({}, {
+                status: 502,
+            });
+            (0, test_utils_1.fetchOnce)({}, {
+                status: 500,
+            });
+            (0, test_utils_1.fetchOnce)({
+                data: [
+                    {
+                        resource_type: 'role',
+                        resource_id: 'admin',
+                    },
+                    {
+                        resource_type: 'role',
+                        resource_id: 'manager',
+                    },
+                ],
+                list_metadata: {
+                    before: null,
+                    after: null,
+                },
+            });
+            const { data: resources } = yield workos.fga.listResources();
+            expect((0, test_utils_1.fetchURL)()).toContain('/fga/v1/resources');
+            expect(resources).toMatchObject([
+                {
+                    resourceType: 'role',
+                    resourceId: 'admin',
+                },
+                {
+                    resourceType: 'role',
+                    resourceId: 'manager',
+                },
+            ]);
+        }));
+        it('fails to list resources after max retries', () => __awaiter(void 0, void 0, void 0, function* () {
+            jest_fetch_mock_1.default.mockResponse(JSON.stringify({
+                message: 'Internal Server Error',
+            }), { status: 500 });
+            try {
+                yield workos.fga.listResources();
+            }
+            catch (e) {
+                expect(e).toBeInstanceOf(exceptions_1.GenericServerException);
+            }
+        }), 8000);
         it('sends correct params when filtering', () => __awaiter(void 0, void 0, void 0, function* () {
             (0, test_utils_1.fetchOnce)({
                 data: [
@@ -177,6 +347,32 @@ describe('FGA', () => {
             expect((0, test_utils_1.fetchURL)()).toContain('/fga/v1/resources/role/admin');
             expect(response).toBeUndefined();
         }));
+        it('should delete resource after one retry', () => __awaiter(void 0, void 0, void 0, function* () {
+            (0, test_utils_1.fetchOnce)({}, {
+                status: 500,
+            });
+            (0, test_utils_1.fetchOnce)();
+            const response = yield workos.fga.deleteResource({
+                resourceType: 'role',
+                resourceId: 'admin',
+            });
+            expect((0, test_utils_1.fetchURL)()).toContain('/fga/v1/resources/role/admin');
+            expect(response).toBeUndefined();
+        }));
+        it('fails to delete resource after max retries', () => __awaiter(void 0, void 0, void 0, function* () {
+            jest_fetch_mock_1.default.mockResponse(JSON.stringify({
+                message: 'Internal Server Error',
+            }), { status: 500 });
+            try {
+                yield workos.fga.deleteResource({
+                    resourceType: 'role',
+                    resourceId: 'admin',
+                });
+            }
+            catch (e) {
+                expect(e).toBeInstanceOf(exceptions_1.GenericServerException);
+            }
+        }), 8000);
     });
     describe('batchWriteResources', () => {
         it('batch create resources', () => __awaiter(void 0, void 0, void 0, function* () {
@@ -244,6 +440,110 @@ describe('FGA', () => {
                 },
             ]);
         }));
+        it('batch create resources after one retry', () => __awaiter(void 0, void 0, void 0, function* () {
+            (0, test_utils_1.fetchOnce)({}, {
+                status: 500,
+            });
+            (0, test_utils_1.fetchOnce)({
+                data: [
+                    {
+                        resource_type: 'role',
+                        resource_id: 'admin',
+                        meta: {
+                            description: 'The admin role',
+                        },
+                    },
+                    {
+                        resource_type: 'role',
+                        resource_id: 'manager',
+                    },
+                    {
+                        resource_type: 'role',
+                        resource_id: 'employee',
+                    },
+                ],
+            });
+            const createdResources = yield workos.fga.batchWriteResources({
+                op: interfaces_1.ResourceOp.Create,
+                resources: [
+                    {
+                        resource: {
+                            resourceType: 'role',
+                            resourceId: 'admin',
+                        },
+                        meta: {
+                            description: 'The admin role',
+                        },
+                    },
+                    {
+                        resource: {
+                            resourceType: 'role',
+                            resourceId: 'manager',
+                        },
+                    },
+                    {
+                        resource: {
+                            resourceType: 'role',
+                            resourceId: 'employee',
+                        },
+                    },
+                ],
+            });
+            expect((0, test_utils_1.fetchURL)()).toContain('/fga/v1/resources/batch');
+            expect(createdResources).toMatchObject([
+                {
+                    resourceType: 'role',
+                    resourceId: 'admin',
+                    meta: {
+                        description: 'The admin role',
+                    },
+                },
+                {
+                    resourceType: 'role',
+                    resourceId: 'manager',
+                },
+                {
+                    resourceType: 'role',
+                    resourceId: 'employee',
+                },
+            ]);
+        }));
+        it('fails to batch create resources after max retries', () => __awaiter(void 0, void 0, void 0, function* () {
+            jest_fetch_mock_1.default.mockResponse(JSON.stringify({
+                message: 'Internal Server Error',
+            }), { status: 500 });
+            try {
+                yield workos.fga.batchWriteResources({
+                    op: interfaces_1.ResourceOp.Create,
+                    resources: [
+                        {
+                            resource: {
+                                resourceType: 'role',
+                                resourceId: 'admin',
+                            },
+                            meta: {
+                                description: 'The admin role',
+                            },
+                        },
+                        {
+                            resource: {
+                                resourceType: 'role',
+                                resourceId: 'manager',
+                            },
+                        },
+                        {
+                            resource: {
+                                resourceType: 'role',
+                                resourceId: 'employee',
+                            },
+                        },
+                    ],
+                });
+            }
+            catch (e) {
+                expect(e).toBeInstanceOf(exceptions_1.GenericServerException);
+            }
+        }), 8000);
         it('batch delete resources', () => __awaiter(void 0, void 0, void 0, function* () {
             (0, test_utils_1.fetchOnce)({
                 data: [
@@ -365,6 +665,62 @@ describe('FGA', () => {
                 warrantToken: 'some_token',
             });
         }));
+        it('should create warrant after one retry', () => __awaiter(void 0, void 0, void 0, function* () {
+            (0, test_utils_1.fetchOnce)({}, {
+                status: 500,
+            });
+            (0, test_utils_1.fetchOnce)({
+                warrant_token: 'some_token',
+            });
+            const warrantToken = yield workos.fga.writeWarrant({
+                op: interfaces_1.WarrantOp.Create,
+                resource: {
+                    resourceType: 'role',
+                    resourceId: 'admin',
+                },
+                relation: 'member',
+                subject: {
+                    resourceType: 'user',
+                    resourceId: 'user_123',
+                },
+            });
+            expect((0, test_utils_1.fetchURL)()).toContain('/fga/v1/warrants');
+            expect((0, test_utils_1.fetchBody)()).toEqual({
+                op: 'create',
+                resource_type: 'role',
+                resource_id: 'admin',
+                relation: 'member',
+                subject: {
+                    resource_type: 'user',
+                    resource_id: 'user_123',
+                },
+            });
+            expect(warrantToken).toMatchObject({
+                warrantToken: 'some_token',
+            });
+        }));
+        it('fails to create warrant after max retries', () => __awaiter(void 0, void 0, void 0, function* () {
+            jest_fetch_mock_1.default.mockResponse(JSON.stringify({
+                message: 'Internal Server Error',
+            }), { status: 500 });
+            try {
+                yield workos.fga.writeWarrant({
+                    op: interfaces_1.WarrantOp.Create,
+                    resource: {
+                        resourceType: 'role',
+                        resourceId: 'admin',
+                    },
+                    relation: 'member',
+                    subject: {
+                        resourceType: 'user',
+                        resourceId: 'user_123',
+                    },
+                });
+            }
+            catch (e) {
+                expect(e).toBeInstanceOf(exceptions_1.GenericServerException);
+            }
+        }), 8000);
         it('should delete warrant with delete op', () => __awaiter(void 0, void 0, void 0, function* () {
             (0, test_utils_1.fetchOnce)({
                 warrant_token: 'some_token',
@@ -475,6 +831,133 @@ describe('FGA', () => {
                 warrantToken: 'some_token',
             });
         }));
+        it('should batch write warrants after one retry', () => __awaiter(void 0, void 0, void 0, function* () {
+            (0, test_utils_1.fetchOnce)({}, {
+                status: 500,
+            });
+            (0, test_utils_1.fetchOnce)({
+                warrant_token: 'some_token',
+            });
+            const warrantToken = yield workos.fga.batchWriteWarrants([
+                {
+                    resource: {
+                        resourceType: 'role',
+                        resourceId: 'admin',
+                    },
+                    relation: 'member',
+                    subject: {
+                        resourceType: 'user',
+                        resourceId: 'user_123',
+                    },
+                },
+                {
+                    op: interfaces_1.WarrantOp.Create,
+                    resource: {
+                        resourceType: 'role',
+                        resourceId: 'admin',
+                    },
+                    relation: 'member',
+                    subject: {
+                        resourceType: 'user',
+                        resourceId: 'user_124',
+                    },
+                },
+                {
+                    op: interfaces_1.WarrantOp.Delete,
+                    resource: {
+                        resourceType: 'role',
+                        resourceId: 'admin',
+                    },
+                    relation: 'member',
+                    subject: {
+                        resourceType: 'user',
+                        resourceId: 'user_125',
+                    },
+                },
+            ]);
+            expect((0, test_utils_1.fetchURL)()).toContain('/fga/v1/warrants');
+            expect((0, test_utils_1.fetchBody)()).toEqual([
+                {
+                    resource_type: 'role',
+                    resource_id: 'admin',
+                    relation: 'member',
+                    subject: {
+                        resource_type: 'user',
+                        resource_id: 'user_123',
+                    },
+                },
+                {
+                    op: 'create',
+                    resource_type: 'role',
+                    resource_id: 'admin',
+                    relation: 'member',
+                    subject: {
+                        resource_type: 'user',
+                        resource_id: 'user_124',
+                    },
+                },
+                {
+                    op: 'delete',
+                    resource_type: 'role',
+                    resource_id: 'admin',
+                    relation: 'member',
+                    subject: {
+                        resource_type: 'user',
+                        resource_id: 'user_125',
+                    },
+                },
+            ]);
+            expect(warrantToken).toMatchObject({
+                warrantToken: 'some_token',
+            });
+        }));
+        it('fails to batch write warrants after max retries', () => __awaiter(void 0, void 0, void 0, function* () {
+            jest_fetch_mock_1.default.mockResponse(JSON.stringify({
+                message: 'Internal Server Error',
+            }), { status: 500 });
+            try {
+                yield workos.fga.batchWriteWarrants([
+                    {
+                        resource: {
+                            resourceType: 'role',
+                            resourceId: 'admin',
+                        },
+                        relation: 'member',
+                        subject: {
+                            resourceType: 'user',
+                            resourceId: 'user_123',
+                        },
+                    },
+                    {
+                        op: interfaces_1.WarrantOp.Create,
+                        resource: {
+                            resourceType: 'role',
+                            resourceId: 'admin',
+                        },
+                        relation: 'member',
+                        subject: {
+                            resourceType: 'user',
+                            resourceId: 'user_124',
+                        },
+                    },
+                    {
+                        op: interfaces_1.WarrantOp.Delete,
+                        resource: {
+                            resourceType: 'role',
+                            resourceId: 'admin',
+                        },
+                        relation: 'member',
+                        subject: {
+                            resourceType: 'user',
+                            resourceId: 'user_125',
+                        },
+                    },
+                ]);
+            }
+            catch (e) {
+                expect(e).toBeInstanceOf(exceptions_1.GenericServerException);
+            }
+        }), 8000);
     });
     describe('listWarrants', () => {
         it('should list warrants', () => __awaiter(void 0, void 0, void 0, function* () {
@@ -529,6 +1012,72 @@ describe('FGA', () => {
                 },
             ]);
         }));
+        it('should list warrants after one retry', () => __awaiter(void 0, void 0, void 0, function* () {
+            (0, test_utils_1.fetchOnce)({}, {
+                status: 500,
+            });
+            (0, test_utils_1.fetchOnce)({
+                data: [
+                    {
+                        resource_type: 'role',
+                        resource_id: 'admin',
+                        relation: 'member',
+                        subject: {
+                            resource_type: 'user',
+                            resource_id: 'user_123',
+                        },
+                    },
+                    {
+                        resource_type: 'role',
+                        resource_id: 'admin',
+                        relation: 'member',
+                        subject: {
+                            resource_type: 'user',
+                            resource_id: 'user_124',
+                        },
+                        policy: 'region == "us"',
+                    },
+                ],
+                list_metadata: {
+                    before: null,
+                    after: null,
+                },
+            });
+            const { data: warrants } = yield workos.fga.listWarrants();
+            expect((0, test_utils_1.fetchURL)()).toContain('/fga/v1/warrants');
+            expect(warrants).toMatchObject([
+                {
+                    resourceType: 'role',
+                    resourceId: 'admin',
+                    relation: 'member',
+                    subject: {
+                        resourceType: 'user',
+                        resourceId: 'user_123',
+                    },
+                },
+                {
+                    resourceType: 'role',
+                    resourceId: 'admin',
+                    relation: 'member',
+                    subject: {
+                        resourceType: 'user',
+                        resourceId: 'user_124',
+                    },
+                    policy: 'region == "us"',
+                },
+            ]);
+        }));
+        it('fails to list warrants after max retries', () => __awaiter(void 0, void 0, void 0, function* () {
+            jest_fetch_mock_1.default.mockResponse(JSON.stringify({
+                message: 'Internal Server Error',
+            }), { status: 500 });
+            try {
+                yield workos.fga.listWarrants();
+            }
+            catch (e) {
+                expect(e).toBeInstanceOf(exceptions_1.GenericServerException);
+            }
+        }), 8000);
         it('sends correct params when filtering', () => __awaiter(void 0, void 0, void 0, function* () {
             (0, test_utils_1.fetchOnce)({
                 data: [
@@ -604,6 +1153,66 @@ describe('FGA', () => {
                 },
             ]);
         }));
+        it('makes query request after one retry', () => __awaiter(void 0, void 0, void 0, function* () {
+            (0, test_utils_1.fetchOnce)({}, {
+                status: 500,
+            });
+            (0, test_utils_1.fetchOnce)({
+                data: [
+                    {
+                        resource_type: 'role',
+                        resource_id: 'admin',
+                        warrant: {
+                            resource_type: 'role',
+                            resource_id: 'admin',
+                            relation: 'member',
+                            subject: {
+                                resource_type: 'user',
+                                resource_id: 'user_123',
+                            },
+                        },
+                        is_implicit: false,
+                    },
+                ],
+                list_metadata: {
+                    before: null,
+                    after: null,
+                },
+            });
+            const { data: queryResults } = yield workos.fga.query({
+                q: 'select role where user:user_123 is member',
+            });
+            expect((0, test_utils_1.fetchURL)()).toContain('/fga/v1/query');
+            expect(queryResults).toMatchObject([
+                {
+                    resourceType: 'role',
+                    resourceId: 'admin',
+                    warrant: {
+                        resourceType: 'role',
+                        resourceId: 'admin',
+                        relation: 'member',
+                        subject: {
+                            resourceType: 'user',
+                            resourceId: 'user_123',
+                        },
+                    },
+                    isImplicit: false,
+                },
+            ]);
+        }));
+        it('fails to make query after max retries', () => __awaiter(void 0, void 0, void 0, function* () {
+            jest_fetch_mock_1.default.mockResponse(JSON.stringify({
+                message: 'Internal Server Error',
+            }), { status: 500 });
+            try {
+                yield workos.fga.query({
+                    q: 'select role where user:user_123 is member',
+                });
+            }
+            catch (e) {
+                expect(e).toBeInstanceOf(exceptions_1.GenericServerException);
+            }
+        }), 8000);
         it('sends correct params and options', () => __awaiter(void 0, void 0, void 0, function* () {
             (0, test_utils_1.fetchOnce)({
                 data: [

package/lib/organizations/fixtures/clear-stripe-customer-id.json

@@ -0,0 +1,13 @@
+{
+    "name": "Test Organization 3",
+    "object": "organization",
+    "id": "org_01EHT88Z8J8795GZNQ4ZP1J81T",
+    "allow_profiles_outside_organization": false,
+    "domains": [
+        {
+            "domain": "example.com",
+            "object": "organization_domain",
+            "id": "org_domain_01EHT88Z8WZEFWYPM6EC9BX2R8"
+        }
+    ]
+}