@workos-inc/node 7.40.1 → 7.42.0

package/lib/vault/vault-live-test.spec.js

@@ -0,0 +1,245 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const jest_fetch_mock_1 = require("jest-fetch-mock");
+const workos_1 = require("../workos");
+const crypto_1 = require("crypto");
+const index_worker_1 = require("../index.worker");
+const conflict_exception_1 = require("../common/exceptions/conflict.exception");
+describe.skip('Vault Live Test', () => {
+    let workos;
+    const secretPrefix = (0, crypto_1.randomUUID)();
+    beforeAll(() => {
+        (0, jest_fetch_mock_1.disableFetchMocks)();
+        workos = new workos_1.WorkOS('API_KEY');
+    });
+    afterAll(() => {
+        (0, jest_fetch_mock_1.enableFetchMocks)();
+    });
+    afterEach(() => __awaiter(void 0, void 0, void 0, function* () {
+        let listLimit = 0;
+        let before;
+        do {
+            const allSecrets = yield workos.vault.listSecrets({ after: before });
+            for (const secret of allSecrets.data) {
+                if (secret.name.startsWith(secretPrefix)) {
+                    yield workos.vault.deleteSecret({ id: secret.id });
+                }
+            }
+            before = allSecrets.listMetadata.before;
+            listLimit++;
+        } while (listLimit < 100 && before !== undefined);
+    }));
+    describe('CRUD secrets', () => {
+        it('Creates secrets', () => __awaiter(void 0, void 0, void 0, function* () {
+            const secretName = `${secretPrefix}-lima`;
+            const newSecret = yield workos.vault.createSecret({
+                name: secretName,
+                value: 'Huacaya 27.7 micron',
+                context: { fiber: 'Alpalca' },
+            });
+            const expectedMetadata = {
+                id: expect.any(String),
+                context: {
+                    fiber: 'Alpalca',
+                },
+                environmentId: expect.any(String),
+                keyId: expect.any(String),
+                updatedAt: expect.any(Date),
+                updatedBy: {
+                    id: expect.any(String),
+                    name: expect.any(String),
+                },
+                versionId: expect.any(String),
+            };
+            expect(newSecret).toStrictEqual(expectedMetadata);
+            const secretValue = yield workos.vault.readSecret({ id: newSecret.id });
+            expect(secretValue).toStrictEqual({
+                id: newSecret.id,
+                name: secretName,
+                value: 'Huacaya 27.7 micron',
+                metadata: expectedMetadata,
+            });
+        }));
+        it('Fails to create secrets with the same name', () => __awaiter(void 0, void 0, void 0, function* () {
+            const secretName = `${secretPrefix}-lima`;
+            yield workos.vault.createSecret({
+                name: secretName,
+                value: 'Huacaya 27.7 micron',
+                context: { fiber: 'Alpalca' },
+            });
+            yield expect(workos.vault.createSecret({
+                name: secretName,
+                value: 'Huacaya 27.7 micron',
+                context: { fiber: 'Alpalca' },
+            })).rejects.toThrow(conflict_exception_1.ConflictException);
+        }));
+        it('Updates secrets', () => __awaiter(void 0, void 0, void 0, function* () {
+            const secretName = `${secretPrefix}-cusco`;
+            const newSecret = yield workos.vault.createSecret({
+                name: secretName,
+                value: 'Tapada 20-30 micron',
+                context: { fiber: 'Alpalca' },
+            });
+            const updatedSecret = yield workos.vault.updateSecret({
+                id: newSecret.id,
+                value: 'Ccara 30-40 micron',
+            });
+            const expectedMetadata = {
+                id: expect.any(String),
+                context: {
+                    fiber: 'Alpalca',
+                },
+                environmentId: expect.any(String),
+                keyId: expect.any(String),
+                updatedAt: expect.any(Date),
+                updatedBy: {
+                    id: expect.any(String),
+                    name: expect.any(String),
+                },
+                versionId: expect.any(String),
+            };
+            expect(updatedSecret).toStrictEqual({
+                id: newSecret.id,
+                name: secretName,
+                value: undefined,
+                metadata: expectedMetadata,
+            });
+            const secretValue = yield workos.vault.readSecret({ id: newSecret.id });
+            expect(secretValue).toStrictEqual({
+                id: newSecret.id,
+                name: secretName,
+                value: 'Ccara 30-40 micron',
+                metadata: expectedMetadata,
+            });
+        }));
+        it('Fails to update secrets with wrong version check', () => __awaiter(void 0, void 0, void 0, function* () {
+            const secretName = `${secretPrefix}-cusco`;
+            const newSecret = yield workos.vault.createSecret({
+                name: secretName,
+                value: 'Tapada 20-30 micron',
+                context: { fiber: 'Alpalca' },
+            });
+            yield workos.vault.updateSecret({
+                id: newSecret.id,
+                value: 'Ccara 30-40 micron',
+            });
+            yield expect(workos.vault.updateSecret({
+                id: newSecret.id,
+                value: 'Ccara 30-40 micron',
+                versionCheck: newSecret.versionId,
+            })).rejects.toThrow(conflict_exception_1.ConflictException);
+        }));
+        it('Deletes secrets', () => __awaiter(void 0, void 0, void 0, function* () {
+            const secretName = `${secretPrefix}-machu`;
+            const newSecret = yield workos.vault.createSecret({
+                name: secretName,
+                value: 'Tapada 20-30 micron',
+                context: { fiber: 'Alpalca' },
+            });
+            yield workos.vault.deleteSecret({ id: newSecret.id });
+            yield expect(workos.vault.readSecret({ id: newSecret.id })).rejects.toThrow(index_worker_1.NotFoundException);
+        }));
+        it('Describes secrets', () => __awaiter(void 0, void 0, void 0, function* () {
+            const secretName = `${(0, crypto_1.randomUUID)()}-trujillo`;
+            const newSecret = yield workos.vault.createSecret({
+                name: secretName,
+                value: 'Qiviut 11-13 micron',
+                context: { fiber: 'Musk Ox' },
+            });
+            const secretDescription = yield workos.vault.describeSecret({
+                id: newSecret.id,
+            });
+            const expectedMetadata = {
+                id: expect.any(String),
+                context: {
+                    fiber: 'Musk Ox',
+                },
+                environmentId: expect.any(String),
+                keyId: expect.any(String),
+                updatedAt: expect.any(Date),
+                updatedBy: {
+                    id: expect.any(String),
+                    name: expect.any(String),
+                },
+                versionId: expect.any(String),
+            };
+            expect(secretDescription).toStrictEqual({
+                id: newSecret.id,
+                name: secretName,
+                metadata: expectedMetadata,
+                value: undefined,
+            });
+        }));
+        it('Lists secrets with pagination', () => __awaiter(void 0, void 0, void 0, function* () {
+            const secretNames = [];
+            const numSecrets = 6;
+            const listPrefix = `${secretPrefix}-${(0, crypto_1.randomUUID)()}`;
+            for (let i = 0; i < numSecrets; i++) {
+                const secretName = `${listPrefix}-${i}`;
+                yield workos.vault.createSecret({
+                    name: secretName,
+                    value: 'Qiviut 11-13 micron',
+                    context: { fiber: 'Musk Ox' },
+                });
+                secretNames.push(secretName);
+            }
+            const allSecretNames = [];
+            let before;
+            do {
+                const list = yield workos.vault.listSecrets({
+                    limit: 2,
+                    after: before,
+                });
+                for (const secret of list.data) {
+                    if (secret.name.startsWith(listPrefix)) {
+                        allSecretNames.push(secret.name);
+                    }
+                }
+                before = list.listMetadata.before;
+            } while (before !== undefined);
+            const missingSecrets = secretNames.filter((name) => !allSecretNames.includes(name));
+            expect(allSecretNames.length).toEqual(numSecrets);
+            expect(missingSecrets).toStrictEqual([]);
+        }));
+        it('Lists secret versions', () => __awaiter(void 0, void 0, void 0, function* () {
+            const secretName = `${secretPrefix}-arequipa`;
+            const newSecret = yield workos.vault.createSecret({
+                name: secretName,
+                value: 'Tapada 20-30 micron',
+                context: { fiber: 'Alpalca' },
+            });
+            const updatedSecret = yield workos.vault.updateSecret({
+                id: newSecret.id,
+                value: 'Ccara 30-40 micron',
+            });
+            const versions = yield workos.vault.listSecretVersions({
+                id: newSecret.id,
+            });
+            expect(versions.length).toBe(2);
+            const currentVersion = versions.find((v) => v.currentVersion);
+            expect(currentVersion === null || currentVersion === void 0 ? void 0 : currentVersion.id).toBe(updatedSecret.metadata.versionId);
+            const firstVersion = versions.find((v) => v.id === newSecret.versionId);
+            expect(firstVersion === null || firstVersion === void 0 ? void 0 : firstVersion.currentVersion).toBe(false);
+        }));
+    });
+    describe('encrypt and decrypt', () => {
+        it('encrypts and decrypts data', () => __awaiter(void 0, void 0, void 0, function* () {
+            const superSecret = 'hot water freezes faster than cold water';
+            const keyContext = {
+                everything: 'everywhere',
+            };
+            const encrypted = yield workos.vault.encrypt(superSecret, keyContext);
+            const decrypted = yield workos.vault.decrypt(encrypted);
+            expect(decrypted).toBe(superSecret);
+        }));
+    });
+});

package/lib/vault/vault.d.ts

@@ -0,0 +1,19 @@
+import { PaginationOptions } from '../index.worker';
+import { WorkOS } from '../workos';
+import { CreateDataKeyOptions, CreateSecretOptions, DataKey, DataKeyPair, DecryptDataKeyOptions, DeleteSecretOptions, ReadSecretOptions, SecretContext, SecretDigest, SecretMetadata, SecretVersion, UpdateSecretOptions, VaultSecret } from './interfaces';
+import { List } from '../common/interfaces';
+export declare class Vault {
+    private readonly workos;
+    constructor(workos: WorkOS);
+    createSecret(options: CreateSecretOptions): Promise<SecretMetadata>;
+    listSecrets(options?: PaginationOptions | undefined): Promise<List<SecretDigest>>;
+    listSecretVersions(options: ReadSecretOptions): Promise<SecretVersion[]>;
+    readSecret(options: ReadSecretOptions): Promise<VaultSecret>;
+    describeSecret(options: ReadSecretOptions): Promise<VaultSecret>;
+    updateSecret(options: UpdateSecretOptions): Promise<VaultSecret>;
+    deleteSecret(options: DeleteSecretOptions): Promise<void>;
+    createDataKey(options: CreateDataKeyOptions): Promise<DataKeyPair>;
+    decryptDataKey(options: DecryptDataKeyOptions): Promise<DataKey>;
+    encrypt(data: string, context: SecretContext): Promise<string>;
+    decrypt(encryptedData: string): Promise<string>;
+}

package/lib/vault/vault.js

@@ -0,0 +1,97 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Vault = void 0;
+const decrypt_1 = require("./cryptography/decrypt");
+const encrypt_1 = require("./cryptography/encrypt");
+const vault_key_serializer_1 = require("./serializers/vault-key.serializer");
+const vault_secret_serializer_1 = require("./serializers/vault-secret.serializer");
+class Vault {
+    constructor(workos) {
+        this.workos = workos;
+    }
+    createSecret(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { data } = yield this.workos.post(`/vault/v1/kv`, (0, vault_secret_serializer_1.serializeCreateSecretEntity)(options));
+            return (0, vault_secret_serializer_1.deserializeSecretMetadata)(data);
+        });
+    }
+    listSecrets(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const url = new URL('/vault/v1/kv', this.workos.baseURL);
+            if (options === null || options === void 0 ? void 0 : options.after) {
+                url.searchParams.set('after', options.after);
+            }
+            if (options === null || options === void 0 ? void 0 : options.limit) {
+                url.searchParams.set('limit', options.limit.toString());
+            }
+            const { data } = yield this.workos.get(url.toString());
+            return (0, vault_secret_serializer_1.deserializeListSecrets)(data);
+        });
+    }
+    listSecretVersions(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { data } = yield this.workos.get(`/vault/v1/kv/${encodeURIComponent(options.id)}/versions`);
+            return (0, vault_secret_serializer_1.desrializeListSecretVersions)(data);
+        });
+    }
+    readSecret(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { data } = yield this.workos.get(`/vault/v1/kv/${encodeURIComponent(options.id)}`);
+            return (0, vault_secret_serializer_1.deserializeSecret)(data);
+        });
+    }
+    describeSecret(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { data } = yield this.workos.get(`/vault/v1/kv/${encodeURIComponent(options.id)}/metadata`);
+            return (0, vault_secret_serializer_1.deserializeSecret)(data);
+        });
+    }
+    updateSecret(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { data } = yield this.workos.put(`/vault/v1/kv/${encodeURIComponent(options.id)}`, (0, vault_secret_serializer_1.serializeUpdateSecretEntity)(options));
+            return (0, vault_secret_serializer_1.deserializeSecret)(data);
+        });
+    }
+    deleteSecret(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.workos.delete(`/vault/v1/kv/${encodeURIComponent(options.id)}`);
+        });
+    }
+    createDataKey(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { data } = yield this.workos.post(`/vault/v1/keys/data-key`, options);
+            return (0, vault_key_serializer_1.deserializeCreateDataKeyResponse)(data);
+        });
+    }
+    decryptDataKey(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { data } = yield this.workos.post(`/vault/v1/keys/decrypt`, options);
+            return (0, vault_key_serializer_1.deserializeDecryptDataKeyResponse)(data);
+        });
+    }
+    encrypt(data, context) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { dataKey, encryptedKeys } = yield this.createDataKey({
+                context,
+            });
+            return (0, encrypt_1.encrypt)(data, dataKey.key, encryptedKeys);
+        });
+    }
+    decrypt(encryptedData) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const decoded = (0, decrypt_1.decode)(encryptedData);
+            const dataKey = yield this.decryptDataKey({ keys: decoded.keys });
+            return (0, decrypt_1.decrypt)(decoded, dataKey.key);
+        });
+    }
+}
+exports.Vault = Vault;

package/lib/vault/vault.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/vault/vault.spec.js

@@ -0,0 +1,247 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+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 conflict_exception_1 = require("../common/exceptions/conflict.exception");
+const workos = new workos_1.WorkOS('sk_test_Sz3IQjepeSWaI4cMS4ms4sMuU');
+describe('Vault', () => {
+    beforeEach(() => jest_fetch_mock_1.default.resetMocks());
+    describe('createSecret', () => {
+        it('creates secret', () => __awaiter(void 0, void 0, void 0, function* () {
+            const secretName = 'charger';
+            (0, test_utils_1.fetchOnce)({
+                id: 's1',
+                context: {
+                    type: 'spore',
+                },
+                environment_id: 'xxx',
+                key_id: 'k1',
+                updated_at: '2029-03-17T04:37:46.748303Z',
+                updated_by: {
+                    id: 'key_xxx',
+                    name: 'Local Test Key',
+                },
+                version_id: 'v1',
+            });
+            const resource = yield workos.vault.createSecret({
+                name: secretName,
+                context: { type: 'spore' },
+                value: 'Full speed ahead',
+            });
+            expect((0, test_utils_1.fetchURL)()).toContain(`/vault/v1/kv`);
+            expect((0, test_utils_1.fetchMethod)()).toBe('POST');
+            expect(resource).toStrictEqual({
+                id: 's1',
+                context: {
+                    type: 'spore',
+                },
+                environmentId: 'xxx',
+                keyId: 'k1',
+                updatedAt: new Date(Date.parse('2029-03-17T04:37:46.748303Z')),
+                updatedBy: {
+                    id: 'key_xxx',
+                    name: 'Local Test Key',
+                },
+                versionId: 'v1',
+            });
+        }));
+        it('throws an error if secret exists', () => __awaiter(void 0, void 0, void 0, function* () {
+            const secretName = 'charger';
+            (0, test_utils_1.fetchOnce)({
+                error: 'Item already exists',
+            }, { status: 409 });
+            yield expect(workos.vault.createSecret({
+                name: secretName,
+                context: { type: 'spore' },
+                value: 'Full speed ahead',
+            })).rejects.toThrow(conflict_exception_1.ConflictException);
+            expect((0, test_utils_1.fetchURL)()).toContain(`/vault/v1/kv`);
+            expect((0, test_utils_1.fetchMethod)()).toBe('POST');
+        }));
+    });
+    describe('readSecret', () => {
+        it('reads a secret by id', () => __awaiter(void 0, void 0, void 0, function* () {
+            const secretName = 'lima';
+            const secretId = 'secret1';
+            (0, test_utils_1.fetchOnce)({
+                id: secretId,
+                metadata: {
+                    id: secretId,
+                    context: {
+                        emporer: 'groove',
+                    },
+                    environment_id: 'environment_d',
+                    key_id: 'key1',
+                    updated_at: '2025-03-11T02:18:54.250931Z',
+                    updated_by: {
+                        id: 'key_xxx',
+                        name: 'Local Test Key',
+                    },
+                    version_id: 'version1',
+                },
+                name: secretName,
+                value: 'Pull the lever Gronk',
+            });
+            const resource = yield workos.vault.readSecret({
+                id: secretId,
+            });
+            expect((0, test_utils_1.fetchURL)()).toContain(`/vault/v1/kv/${secretId}`);
+            expect((0, test_utils_1.fetchMethod)()).toBe('GET');
+            expect(resource).toStrictEqual({
+                id: secretId,
+                metadata: {
+                    id: secretId,
+                    context: {
+                        emporer: 'groove',
+                    },
+                    environmentId: 'environment_d',
+                    keyId: 'key1',
+                    updatedAt: new Date(Date.parse('2025-03-11T02:18:54.250931Z')),
+                    updatedBy: {
+                        id: 'key_xxx',
+                        name: 'Local Test Key',
+                    },
+                    versionId: 'version1',
+                },
+                name: secretName,
+                value: 'Pull the lever Gronk',
+            });
+        }));
+    });
+    describe('listSecrets', () => {
+        it('gets a paginated list of secrets', () => __awaiter(void 0, void 0, void 0, function* () {
+            (0, test_utils_1.fetchOnce)({
+                data: [
+                    {
+                        id: 's1',
+                        name: 'charger',
+                        updated_at: '2029-03-17T04:37:46.748303Z',
+                    },
+                ],
+                list_metadata: {
+                    after: null,
+                    before: 'charger',
+                },
+            });
+            const resource = yield workos.vault.listSecrets();
+            expect((0, test_utils_1.fetchURL)()).toContain(`/vault/v1/kv`);
+            expect((0, test_utils_1.fetchMethod)()).toBe('GET');
+            expect(resource).toStrictEqual({
+                object: 'list',
+                data: [
+                    {
+                        id: 's1',
+                        name: 'charger',
+                        updatedAt: new Date(Date.parse('2029-03-17T04:37:46.748303Z')),
+                    },
+                ],
+                listMetadata: {
+                    after: undefined,
+                    before: 'charger',
+                },
+            });
+        }));
+    });
+    describe('listSecretVersions', () => {
+        it('gets a paginated list of secret versions', () => __awaiter(void 0, void 0, void 0, function* () {
+            (0, test_utils_1.fetchOnce)({
+                data: [
+                    {
+                        id: 'raZUqoHteQkLihH6AG5bj6sYAqMcJS76',
+                        size: 270,
+                        etag: '"5147c963627323edcb15910ceea573bf"',
+                        created_at: '2029-03-17T15:51:57.000000Z',
+                        current_version: true,
+                    },
+                ],
+                list_metadata: {
+                    after: null,
+                    before: 'raZUqoHteQkLihH6AG5bj6sYAqMcJS76',
+                },
+            });
+            const resource = yield workos.vault.listSecretVersions({ id: 'secret1' });
+            expect((0, test_utils_1.fetchURL)()).toContain(`/vault/v1/kv/secret1/versions`);
+            expect((0, test_utils_1.fetchMethod)()).toBe('GET');
+            expect(resource).toStrictEqual([
+                {
+                    createdAt: new Date(Date.parse('2029-03-17T15:51:57.000000Z')),
+                    currentVersion: true,
+                    id: 'raZUqoHteQkLihH6AG5bj6sYAqMcJS76',
+                },
+            ]);
+        }));
+    });
+    describe('updateSecret', () => {
+        it('updates secret', () => __awaiter(void 0, void 0, void 0, function* () {
+            const secretId = 's1';
+            (0, test_utils_1.fetchOnce)({
+                id: secretId,
+                name: 'charger',
+                metadata: {
+                    id: secretId,
+                    context: {
+                        type: 'spore',
+                    },
+                    environment_id: 'xxx',
+                    key_id: 'k1',
+                    updated_at: '2029-03-17T04:37:46.748303Z',
+                    updated_by: {
+                        id: 'key_xxx',
+                        name: 'Local Test Key',
+                    },
+                    version_id: 'v1',
+                },
+            });
+            const resource = yield workos.vault.updateSecret({
+                id: secretId,
+                value: 'Full speed ahead',
+            });
+            expect((0, test_utils_1.fetchURL)()).toContain(`/vault/v1/kv/${secretId}`);
+            expect((0, test_utils_1.fetchMethod)()).toBe('PUT');
+            expect(resource).toStrictEqual({
+                id: secretId,
+                name: 'charger',
+                metadata: {
+                    id: secretId,
+                    context: {
+                        type: 'spore',
+                    },
+                    environmentId: 'xxx',
+                    keyId: 'k1',
+                    updatedAt: new Date(Date.parse('2029-03-17T04:37:46.748303Z')),
+                    updatedBy: {
+                        id: 'key_xxx',
+                        name: 'Local Test Key',
+                    },
+                    versionId: 'v1',
+                },
+                value: undefined,
+            });
+        }));
+        it('throws an error if secret version check fails', () => __awaiter(void 0, void 0, void 0, function* () {
+            (0, test_utils_1.fetchOnce)({
+                error: 'Item already exists',
+            }, { status: 409 });
+            yield expect(workos.vault.updateSecret({
+                id: 'secret1',
+                value: 'Full speed ahead',
+                versionCheck: 'notaversion',
+            })).rejects.toThrow(conflict_exception_1.ConflictException);
+            expect((0, test_utils_1.fetchURL)()).toContain(`/vault/v1/kv/secret1`);
+            expect((0, test_utils_1.fetchMethod)()).toBe('PUT');
+        }));
+    });
+});

package/lib/workos.d.ts

@@ -15,6 +15,7 @@ import { HttpClient } from './common/net/http-client';
 import { IronSessionProvider } from './common/iron-session/iron-session-provider';
 import { Widgets } from './widgets/widgets';
 import { Actions } from './actions/actions';
+import { Vault } from './vault/vault';
 export declare class WorkOS {
     readonly key?: string | undefined;
     readonly options: WorkOSOptions;
@@ -35,6 +36,7 @@ export declare class WorkOS {
     readonly userManagement: UserManagement;
     readonly fga: FGA;
     readonly widgets: Widgets;
+    readonly vault: Vault;
     constructor(key?: string | undefined, options?: WorkOSOptions);
     createWebhookClient(): Webhooks;
     createActionsClient(): Actions;

package/lib/workos.js

@@ -29,7 +29,9 @@ const subtle_crypto_provider_1 = require("./common/crypto/subtle-crypto-provider
 const fetch_client_1 = require("./common/net/fetch-client");
 const widgets_1 = require("./widgets/widgets");
 const actions_1 = require("./actions/actions");
-const VERSION = '7.40.1';
+const vault_1 = require("./vault/vault");
+const conflict_exception_1 = require("./common/exceptions/conflict.exception");
+const VERSION = '7.42.0';
 const DEFAULT_HOSTNAME = 'api.workos.com';
 const HEADER_AUTHORIZATION = 'Authorization';
 const HEADER_IDEMPOTENCY_KEY = 'Idempotency-Key';
@@ -49,6 +51,7 @@ class WorkOS {
         this.events = new events_1.Events(this);
         this.fga = new fga_1.FGA(this);
         this.widgets = new widgets_1.Widgets(this);
+        this.vault = new vault_1.Vault(this);
         if (!key) {
             // process might be undefined in some environments
             this.key =
@@ -194,6 +197,9 @@ class WorkOS {
                 case 401: {
                     throw new exceptions_1.UnauthorizedException(requestID);
                 }
+                case 409: {
+                    throw new conflict_exception_1.ConflictException({ requestID, message, error });
+                }
                 case 422: {
                     throw new exceptions_1.UnprocessableEntityException({
                         code,

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "7.40.1",
+  "version": "7.42.0",
   "name": "@workos-inc/node",
   "author": "WorkOS",
   "description": "A Node wrapper for the WorkOS API",
@@ -40,6 +40,7 @@
   "dependencies": {
     "iron-session": "~6.3.1",
     "jose": "~5.6.3",
+    "leb": "^1.0.0",
     "pluralize": "8.0.0"
   },
   "devDependencies": {
@@ -73,4 +74,3 @@
     }
   }
 }
-