convex-secret-store 0.1.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.
Files changed (94) hide show
  1. package/LICENSE +201 -0
  2. package/README.md +604 -0
  3. package/dist/client/_generated/_ignore.d.ts +1 -0
  4. package/dist/client/_generated/_ignore.d.ts.map +1 -0
  5. package/dist/client/_generated/_ignore.js +3 -0
  6. package/dist/client/_generated/_ignore.js.map +1 -0
  7. package/dist/client/base64.d.ts +3 -0
  8. package/dist/client/base64.d.ts.map +1 -0
  9. package/dist/client/base64.js +32 -0
  10. package/dist/client/base64.js.map +1 -0
  11. package/dist/client/crypto.d.ts +43 -0
  12. package/dist/client/crypto.d.ts.map +1 -0
  13. package/dist/client/crypto.js +133 -0
  14. package/dist/client/crypto.js.map +1 -0
  15. package/dist/client/errors.d.ts +14 -0
  16. package/dist/client/errors.d.ts.map +1 -0
  17. package/dist/client/errors.js +29 -0
  18. package/dist/client/errors.js.map +1 -0
  19. package/dist/client/index.d.ts +6 -0
  20. package/dist/client/index.d.ts.map +1 -0
  21. package/dist/client/index.js +3 -0
  22. package/dist/client/index.js.map +1 -0
  23. package/dist/client/operations.d.ts +88 -0
  24. package/dist/client/operations.d.ts.map +1 -0
  25. package/dist/client/operations.js +388 -0
  26. package/dist/client/operations.js.map +1 -0
  27. package/dist/client/options.d.ts +27 -0
  28. package/dist/client/options.d.ts.map +1 -0
  29. package/dist/client/options.js +66 -0
  30. package/dist/client/options.js.map +1 -0
  31. package/dist/client/types.d.ts +133 -0
  32. package/dist/client/types.d.ts.map +1 -0
  33. package/dist/client/types.js +2 -0
  34. package/dist/client/types.js.map +1 -0
  35. package/dist/component/_generated/api.d.ts +36 -0
  36. package/dist/component/_generated/api.d.ts.map +1 -0
  37. package/dist/component/_generated/api.js +31 -0
  38. package/dist/component/_generated/api.js.map +1 -0
  39. package/dist/component/_generated/component.d.ts +187 -0
  40. package/dist/component/_generated/component.d.ts.map +1 -0
  41. package/dist/component/_generated/component.js +11 -0
  42. package/dist/component/_generated/component.js.map +1 -0
  43. package/dist/component/_generated/dataModel.d.ts +46 -0
  44. package/dist/component/_generated/dataModel.d.ts.map +1 -0
  45. package/dist/component/_generated/dataModel.js +11 -0
  46. package/dist/component/_generated/dataModel.js.map +1 -0
  47. package/dist/component/_generated/server.d.ts +121 -0
  48. package/dist/component/_generated/server.d.ts.map +1 -0
  49. package/dist/component/_generated/server.js +78 -0
  50. package/dist/component/_generated/server.js.map +1 -0
  51. package/dist/component/cleanup.d.ts +27 -0
  52. package/dist/component/cleanup.d.ts.map +1 -0
  53. package/dist/component/cleanup.js +96 -0
  54. package/dist/component/cleanup.js.map +1 -0
  55. package/dist/component/convex.config.d.ts +3 -0
  56. package/dist/component/convex.config.d.ts.map +1 -0
  57. package/dist/component/convex.config.js +3 -0
  58. package/dist/component/convex.config.js.map +1 -0
  59. package/dist/component/lib.d.ts +177 -0
  60. package/dist/component/lib.d.ts.map +1 -0
  61. package/dist/component/lib.js +531 -0
  62. package/dist/component/lib.js.map +1 -0
  63. package/dist/component/schema.d.ts +73 -0
  64. package/dist/component/schema.d.ts.map +1 -0
  65. package/dist/component/schema.js +45 -0
  66. package/dist/component/schema.js.map +1 -0
  67. package/dist/shared.d.ts +7 -0
  68. package/dist/shared.d.ts.map +1 -0
  69. package/dist/shared.js +12 -0
  70. package/dist/shared.js.map +1 -0
  71. package/package.json +115 -0
  72. package/src/client/_generated/_ignore.ts +1 -0
  73. package/src/client/base64.ts +37 -0
  74. package/src/client/crypto.ts +229 -0
  75. package/src/client/errors.ts +64 -0
  76. package/src/client/index.test.ts +480 -0
  77. package/src/client/index.ts +34 -0
  78. package/src/client/operations.ts +513 -0
  79. package/src/client/options.ts +110 -0
  80. package/src/client/setup.test.ts +26 -0
  81. package/src/client/types.ts +213 -0
  82. package/src/component/_generated/api.ts +52 -0
  83. package/src/component/_generated/component.ts +222 -0
  84. package/src/component/_generated/dataModel.ts +60 -0
  85. package/src/component/_generated/server.ts +156 -0
  86. package/src/component/cleanup.test.ts +91 -0
  87. package/src/component/cleanup.ts +124 -0
  88. package/src/component/convex.config.ts +3 -0
  89. package/src/component/lib.test.ts +202 -0
  90. package/src/component/lib.ts +659 -0
  91. package/src/component/schema.ts +48 -0
  92. package/src/component/setup.test.ts +11 -0
  93. package/src/shared.ts +28 -0
  94. package/src/test.ts +18 -0
@@ -0,0 +1,513 @@
1
+ import type { ComponentApi } from "../component/_generated/component.js";
2
+ import {
3
+ decryptSecret,
4
+ encryptSecret,
5
+ importKey,
6
+ rewrapDEK,
7
+ } from "./crypto.js";
8
+ import {
9
+ invalidArgumentError,
10
+ keyVersionUnavailableError,
11
+ operationFailedError,
12
+ } from "./errors.js";
13
+ import {
14
+ assertNullableNonNegativeInteger,
15
+ normalizeSecretStoreOptions,
16
+ type NormalizedSecretStoreOptions,
17
+ type SecretStoreOptions,
18
+ } from "./options.js";
19
+ import type {
20
+ CleanupEventsArgs,
21
+ CleanupEventsResult,
22
+ CleanupSecretsArgs,
23
+ CleanupSecretsResult,
24
+ GetArgs,
25
+ GetResult,
26
+ HasArgs,
27
+ ListArgs,
28
+ ListEventsArgs,
29
+ ListEventsResult,
30
+ ListResult,
31
+ PutArgs,
32
+ PutResult,
33
+ RemoveArgs,
34
+ RemoveResult,
35
+ RotateKeysArgs,
36
+ RotateKeysResult,
37
+ RunMutationCtx,
38
+ RunQueryCtx,
39
+ UpdateArgs,
40
+ UpdateResult,
41
+ SecretStoreTypeOptions,
42
+ } from "./types.js";
43
+
44
+ const DEFAULT_ROTATION_BATCH_SIZE = 100;
45
+ const DEFAULT_SECRET_RETENTION_MS = 30 * 24 * 60 * 60 * 1000;
46
+ const DEFAULT_EVENT_RETENTION_MS = 180 * 24 * 60 * 60 * 1000;
47
+
48
+ function readNamespace(args: object): string | undefined {
49
+ if (!("namespace" in args)) {
50
+ return undefined;
51
+ }
52
+ const namespace = (args as { namespace?: unknown }).namespace;
53
+ if (namespace === undefined) {
54
+ return undefined;
55
+ }
56
+ if (typeof namespace !== "string") {
57
+ return undefined;
58
+ }
59
+ if (namespace.length === 0) {
60
+ throw invalidArgumentError("namespace must not be empty");
61
+ }
62
+ return namespace;
63
+ }
64
+
65
+ function shouldLog(
66
+ configured: "debug" | "warn" | "error" | "none",
67
+ level: "debug" | "warn" | "error",
68
+ ): boolean {
69
+ if (configured === "none") return false;
70
+ if (configured === "debug") return true;
71
+ if (configured === "warn") return level !== "debug";
72
+ return level === "error";
73
+ }
74
+
75
+ function logWithLevel(
76
+ configured: "debug" | "warn" | "error" | "none",
77
+ level: "debug" | "warn" | "error",
78
+ tag: string,
79
+ data: Record<string, unknown>,
80
+ ) {
81
+ if (!shouldLog(configured, level)) {
82
+ return;
83
+ }
84
+ const method =
85
+ level === "error" ? "error" : level === "warn" ? "warn" : "log";
86
+ console[method](`[secret-store:${tag}]`, data);
87
+ }
88
+
89
+ function resolvePutExpiresAt(
90
+ now: number,
91
+ ttlMs: number | null | undefined,
92
+ defaultTtlMs: number | null,
93
+ ) {
94
+ const resolved = ttlMs === undefined ? defaultTtlMs : ttlMs;
95
+ if (resolved === null) {
96
+ return null;
97
+ }
98
+ assertNullableNonNegativeInteger(resolved, "ttlMs");
99
+ return now + resolved;
100
+ }
101
+
102
+ function toThrownError(error: unknown, message: string) {
103
+ return operationFailedError(message, error);
104
+ }
105
+
106
+ export class SecretStore<
107
+ TOptions extends SecretStoreTypeOptions = Record<never, never>,
108
+ > {
109
+ public readonly component: ComponentApi;
110
+ public readonly options: NormalizedSecretStoreOptions;
111
+ private readonly kekCache = new Map<number, Promise<CryptoKey>>();
112
+
113
+ /**
114
+ * Create a typed SecretStore client for a mounted component instance.
115
+ *
116
+ * `keys` must contain one or more versioned KEKs. The first entry is the
117
+ * active key used for new writes; later entries are decrypt-only keys used to
118
+ * read older rows and rotate them forward.
119
+ */
120
+ constructor(component: ComponentApi, options: SecretStoreOptions<TOptions>) {
121
+ this.component = component;
122
+ this.options = normalizeSecretStoreOptions(
123
+ options as SecretStoreOptions<SecretStoreTypeOptions>,
124
+ );
125
+ }
126
+
127
+ private getKEK(version: number): Promise<CryptoKey> {
128
+ const raw = this.options.keyVersions.get(version);
129
+ if (raw === undefined) {
130
+ throw keyVersionUnavailableError(version);
131
+ }
132
+ const cached = this.kekCache.get(version);
133
+ if (cached) {
134
+ return cached;
135
+ }
136
+ const imported = importKey(raw);
137
+ this.kekCache.set(version, imported);
138
+ return imported;
139
+ }
140
+
141
+ /**
142
+ * Encrypt and store a secret value.
143
+ *
144
+ * The plaintext is encrypted client-side with a fresh DEK, that DEK is wrapped
145
+ * with the active KEK, and only ciphertext fields are persisted in Convex.
146
+ * When a secret with the same `namespace + name` already exists, the row is
147
+ * replaced in place and an `updated` audit event is written.
148
+ */
149
+ async put(ctx: RunMutationCtx, args: PutArgs<TOptions>): Promise<PutResult> {
150
+ const now = Date.now();
151
+ const namespace = readNamespace(args);
152
+
153
+ try {
154
+ const expiresAt = resolvePutExpiresAt(
155
+ now,
156
+ args.ttlMs,
157
+ this.options.defaults.ttlMs,
158
+ );
159
+ const payload = await encryptSecret({
160
+ value: args.value,
161
+ namespace,
162
+ name: args.name,
163
+ keyVersion: this.options.activeVersion,
164
+ kek: await this.getKEK(this.options.activeVersion),
165
+ });
166
+
167
+ const result = await ctx.runMutation(this.component.lib.put, {
168
+ namespace,
169
+ name: args.name,
170
+ metadata: args.metadata,
171
+ expiresAt,
172
+ keyVersion: this.options.activeVersion,
173
+ ...payload,
174
+ });
175
+ logWithLevel(this.options.logLevel, "debug", "put", {
176
+ namespace,
177
+ name: args.name,
178
+ secretId: result.secretId,
179
+ isNew: result.isNew,
180
+ });
181
+ return result;
182
+ } catch (error) {
183
+ throw toThrownError(error, `put ${args.name}`);
184
+ }
185
+ }
186
+
187
+ /**
188
+ * Load and decrypt a secret value.
189
+ *
190
+ * Returns `not_found` or `expired` when the backend row is unavailable for
191
+ * use. Returns `key_version_unavailable` when the row exists but the current
192
+ * runtime is missing the KEK version required to unwrap it.
193
+ */
194
+ async get(
195
+ ctx: RunQueryCtx,
196
+ args: GetArgs<TOptions>,
197
+ ): Promise<GetResult<TOptions>> {
198
+ const namespace = readNamespace(args);
199
+
200
+ try {
201
+ const result = await ctx.runQuery(this.component.lib.get, {
202
+ namespace,
203
+ name: args.name,
204
+ now: Date.now(),
205
+ });
206
+ if (!result.ok) {
207
+ return result;
208
+ }
209
+
210
+ const key = this.options.keyVersions.get(result.keyVersion);
211
+ if (key === undefined) {
212
+ return { ok: false, reason: "key_version_unavailable" };
213
+ }
214
+
215
+ const value = await decryptSecret({
216
+ namespace,
217
+ name: args.name,
218
+ encryptedValue: result.encryptedValue,
219
+ iv: result.iv,
220
+ wrappedDEK: result.wrappedDEK,
221
+ dekIv: result.dekIv,
222
+ keyVersion: result.keyVersion,
223
+ kek: await this.getKEK(result.keyVersion),
224
+ });
225
+
226
+ return {
227
+ ok: true,
228
+ value,
229
+ metadata: result.metadata as GetResult<TOptions> extends {
230
+ ok: true;
231
+ metadata: infer M;
232
+ }
233
+ ? M
234
+ : never,
235
+ expiresAt: result.expiresAt,
236
+ updatedAt: result.updatedAt,
237
+ };
238
+ } catch (error) {
239
+ throw toThrownError(error, `get ${args.name}`);
240
+ }
241
+ }
242
+
243
+ /**
244
+ * Check whether a usable secret exists.
245
+ *
246
+ * This is an expiry-aware existence check: expired rows return `false`.
247
+ */
248
+ async has(ctx: RunQueryCtx, args: HasArgs<TOptions>): Promise<boolean> {
249
+ try {
250
+ return await ctx.runQuery(this.component.lib.has, {
251
+ namespace: readNamespace(args),
252
+ name: args.name,
253
+ now: Date.now(),
254
+ });
255
+ } catch (error) {
256
+ throw toThrownError(error, `has ${args.name}`);
257
+ }
258
+ }
259
+
260
+ async remove(
261
+ ctx: RunMutationCtx,
262
+ args: RemoveArgs<TOptions>,
263
+ ): Promise<RemoveResult> {
264
+ try {
265
+ return await ctx.runMutation(this.component.lib.remove, {
266
+ namespace: readNamespace(args),
267
+ name: args.name,
268
+ });
269
+ } catch (error) {
270
+ throw toThrownError(error, `remove ${args.name}`);
271
+ }
272
+ }
273
+
274
+ /**
275
+ * Update plaintext metadata or expiry without rewriting encrypted value bytes.
276
+ *
277
+ * Pass `null` for `metadata` or `expiresAt` to remove those fields entirely.
278
+ */
279
+ async update(
280
+ ctx: RunMutationCtx,
281
+ args: UpdateArgs<TOptions>,
282
+ ): Promise<UpdateResult> {
283
+ assertNullableNonNegativeInteger(args.expiresAt, "expiresAt");
284
+
285
+ try {
286
+ return await ctx.runMutation(this.component.lib.update, {
287
+ namespace: readNamespace(args),
288
+ name: args.name,
289
+ metadata: args.metadata,
290
+ expiresAt: args.expiresAt,
291
+ });
292
+ } catch (error) {
293
+ throw toThrownError(error, `update ${args.name}`);
294
+ }
295
+ }
296
+
297
+ /**
298
+ * List secrets in one namespace.
299
+ *
300
+ * Results are ordered by `updatedAt` and include `effectiveState` so callers
301
+ * can distinguish active and expired rows without additional filtering.
302
+ */
303
+ async list(
304
+ ctx: RunQueryCtx,
305
+ args: ListArgs<TOptions>,
306
+ ): Promise<ListResult<TOptions>> {
307
+ try {
308
+ return (await ctx.runQuery(this.component.lib.list, {
309
+ namespace: readNamespace(args),
310
+ paginationOpts: args.paginationOpts,
311
+ order: args.order,
312
+ now: Date.now(),
313
+ })) as ListResult<TOptions>;
314
+ } catch (error) {
315
+ throw toThrownError(error, "list secrets");
316
+ }
317
+ }
318
+
319
+ /**
320
+ * List audit events for a namespace or one specific secret.
321
+ *
322
+ * In V1, `name` and `type` cannot be combined in the same query. When using a
323
+ * namespaced client, normal event listing requires `namespace`; the only
324
+ * namespace-less variant is a direct `secretId` lookup.
325
+ */
326
+ async listEvents(
327
+ ctx: RunQueryCtx,
328
+ args: ListEventsArgs<TOptions>,
329
+ ): Promise<ListEventsResult<TOptions>> {
330
+ if (args.name !== undefined && args.type !== undefined) {
331
+ throw invalidArgumentError(
332
+ "listEvents does not support name + type in V1",
333
+ );
334
+ }
335
+
336
+ try {
337
+ return (await ctx.runQuery(this.component.lib.listEvents, {
338
+ namespace: readNamespace(args),
339
+ secretId: args.secretId,
340
+ name: args.name,
341
+ type: args.type,
342
+ paginationOpts: args.paginationOpts,
343
+ order: args.order,
344
+ })) as ListEventsResult<TOptions>;
345
+ } catch (error) {
346
+ throw toThrownError(error, "list events");
347
+ }
348
+ }
349
+
350
+ /**
351
+ * Rewrap rows from one KEK version onto the active KEK version.
352
+ *
353
+ * This operation does not rewrite encrypted secret plaintext. It only unwraps
354
+ * each row's stored DEK with `fromVersion` and rewraps that DEK with the
355
+ * active version. Concurrent writes are protected with compare-and-swap checks;
356
+ * stale rows are skipped safely and can be retried in later batches.
357
+ */
358
+ async rotateKeys(
359
+ ctx: RunMutationCtx & RunQueryCtx,
360
+ args: RotateKeysArgs,
361
+ ): Promise<RotateKeysResult> {
362
+ if (!Number.isInteger(args.fromVersion) || args.fromVersion < 0) {
363
+ throw invalidArgumentError("fromVersion must be a non-negative integer");
364
+ }
365
+ const batchSize = args.batchSize ?? DEFAULT_ROTATION_BATCH_SIZE;
366
+ if (!Number.isInteger(batchSize) || batchSize <= 0) {
367
+ throw invalidArgumentError("batchSize must be a positive integer");
368
+ }
369
+
370
+ const toVersion = this.options.activeVersion;
371
+ if (args.fromVersion === toVersion) {
372
+ throw invalidArgumentError(
373
+ "fromVersion must differ from the active version",
374
+ );
375
+ }
376
+ if (!this.options.keyVersions.has(args.fromVersion)) {
377
+ throw keyVersionUnavailableError(args.fromVersion);
378
+ }
379
+
380
+ try {
381
+ const page = await ctx.runQuery(this.component.lib.listByKeyVersion, {
382
+ fromVersion: args.fromVersion,
383
+ order: args.order,
384
+ paginationOpts: {
385
+ numItems: batchSize,
386
+ cursor: args.cursor ?? null,
387
+ },
388
+ });
389
+
390
+ const fromKek = await this.getKEK(args.fromVersion);
391
+ const toKek = await this.getKEK(toVersion);
392
+ let rotated = 0;
393
+ let skipped = 0;
394
+
395
+ for (const row of page.page) {
396
+ const nextWrapped = await rewrapDEK({
397
+ wrappedDEK: row.wrappedDEK,
398
+ dekIv: row.dekIv,
399
+ namespace: row.namespace,
400
+ name: row.name,
401
+ fromVersion: args.fromVersion,
402
+ toVersion,
403
+ fromKek,
404
+ toKek,
405
+ });
406
+
407
+ const result = await ctx.runMutation(
408
+ this.component.lib.updateWrappedDEK,
409
+ {
410
+ secretId: row.secretId,
411
+ expectedKeyVersion: row.keyVersion,
412
+ expectedUpdatedAt: row.updatedAt,
413
+ keyVersion: toVersion,
414
+ wrappedDEK: nextWrapped.wrappedDEK,
415
+ dekIv: nextWrapped.dekIv,
416
+ },
417
+ );
418
+
419
+ if (result.ok) {
420
+ rotated += 1;
421
+ } else {
422
+ skipped += 1;
423
+ }
424
+ }
425
+
426
+ let isDone = page.isDone;
427
+ let continueCursor: string | null = page.continueCursor;
428
+ if (skipped > 0 && page.isDone) {
429
+ const remaining = await ctx.runQuery(
430
+ this.component.lib.listByKeyVersion,
431
+ {
432
+ fromVersion: args.fromVersion,
433
+ order: args.order,
434
+ paginationOpts: {
435
+ numItems: 1,
436
+ cursor: null,
437
+ },
438
+ },
439
+ );
440
+ if (remaining.page.length > 0) {
441
+ isDone = false;
442
+ continueCursor = null;
443
+ }
444
+ }
445
+
446
+ return {
447
+ fromVersion: args.fromVersion,
448
+ toVersion,
449
+ processed: page.page.length,
450
+ rotated,
451
+ skipped,
452
+ isDone,
453
+ continueCursor,
454
+ };
455
+ } catch (error) {
456
+ throw toThrownError(error, `rotate from version ${args.fromVersion}`);
457
+ }
458
+ }
459
+
460
+ /**
461
+ * Hard-delete expired secrets that have been past their expiry timestamp for
462
+ * at least the retention window.
463
+ *
464
+ * The cleanup mutation processes up to 100 rows per run and automatically
465
+ * reschedules itself while backlog remains. Deleting an expired secret writes
466
+ * a final `deleted` audit event with `deletedReason: "expired_cleanup"`.
467
+ */
468
+ async cleanupSecrets(
469
+ ctx: RunMutationCtx,
470
+ args: CleanupSecretsArgs = {},
471
+ ): Promise<CleanupSecretsResult> {
472
+ const retentionMs = args.retentionMs ?? DEFAULT_SECRET_RETENTION_MS;
473
+ if (!Number.isFinite(retentionMs) || retentionMs <= 0) {
474
+ throw invalidArgumentError(
475
+ "retentionMs must be a positive finite number",
476
+ );
477
+ }
478
+
479
+ try {
480
+ return await ctx.runMutation(this.component.cleanup.cleanupSecrets, {
481
+ retentionMs,
482
+ });
483
+ } catch (error) {
484
+ throw toThrownError(error, "cleanup secrets");
485
+ }
486
+ }
487
+
488
+ /**
489
+ * Hard-delete audit events older than the retention window.
490
+ *
491
+ * Event cleanup is independent from secret cleanup and may keep audit rows
492
+ * for much longer than expired secret rows remain in storage.
493
+ */
494
+ async cleanupEvents(
495
+ ctx: RunMutationCtx,
496
+ args: CleanupEventsArgs = {},
497
+ ): Promise<CleanupEventsResult> {
498
+ const retentionMs = args.retentionMs ?? DEFAULT_EVENT_RETENTION_MS;
499
+ if (!Number.isFinite(retentionMs) || retentionMs <= 0) {
500
+ throw invalidArgumentError(
501
+ "retentionMs must be a positive finite number",
502
+ );
503
+ }
504
+
505
+ try {
506
+ return await ctx.runMutation(this.component.cleanup.cleanupEvents, {
507
+ retentionMs,
508
+ });
509
+ } catch (error) {
510
+ throw toThrownError(error, "cleanup events");
511
+ }
512
+ }
513
+ }
@@ -0,0 +1,110 @@
1
+ import { optionsError } from "./errors.js";
2
+ import { decodeBase64 } from "./base64.js";
3
+ import type { SecretStoreTypeOptions } from "./types.js";
4
+
5
+ export type SecretStoreOptions<
6
+ TOptions extends SecretStoreTypeOptions = Record<never, never>,
7
+ > = {
8
+ keys: Array<{ version: number; value: string }>;
9
+ defaults?: {
10
+ ttlMs?: number | null;
11
+ };
12
+ logLevel?: "debug" | "warn" | "error" | "none";
13
+ _types?: TOptions | undefined;
14
+ };
15
+
16
+ export type NormalizedSecretStoreOptions = {
17
+ keys: Array<{ version: number; value: string }>;
18
+ activeVersion: number;
19
+ keyVersions: Map<number, string>;
20
+ defaults: { ttlMs: number | null };
21
+ logLevel: "debug" | "warn" | "error" | "none";
22
+ };
23
+
24
+ const LOG_LEVELS = ["debug", "warn", "error", "none"] as const;
25
+ const DEFAULT_TTL_MS = null as number | null;
26
+
27
+ function decodeBase64Key(value: string): Uint8Array {
28
+ const normalized = value.trim();
29
+ if (normalized.length === 0) {
30
+ throw optionsError("keys[].value must not be empty");
31
+ }
32
+
33
+ try {
34
+ return decodeBase64(normalized);
35
+ } catch (error) {
36
+ throw optionsError(
37
+ `keys[].value must be valid base64-encoded key material: ${String(error)}`,
38
+ );
39
+ }
40
+ }
41
+
42
+ function normalizeLogLevel(
43
+ level: "debug" | "warn" | "error" | "none" | undefined,
44
+ ): "debug" | "warn" | "error" | "none" {
45
+ const resolved = level ?? "warn";
46
+ if (!LOG_LEVELS.includes(resolved)) {
47
+ throw optionsError(`logLevel must be one of: ${LOG_LEVELS.join(", ")}`);
48
+ }
49
+ return resolved;
50
+ }
51
+
52
+ export function assertNullableNonNegativeInteger(
53
+ value: number | null | undefined,
54
+ path: string,
55
+ ) {
56
+ if (value === undefined || value === null) {
57
+ return;
58
+ }
59
+ if (!Number.isInteger(value) || value < 0) {
60
+ throw optionsError(`${path} must be null or a non-negative integer`);
61
+ }
62
+ }
63
+
64
+ export function normalizeSecretStoreOptions(
65
+ options: SecretStoreOptions<SecretStoreTypeOptions>,
66
+ ): NormalizedSecretStoreOptions {
67
+ if (options.keys.length === 0) {
68
+ throw optionsError("keys must contain at least one entry");
69
+ }
70
+
71
+ const seen = new Set<number>();
72
+ const keys = options.keys.map((entry, index) => {
73
+ if (!Number.isInteger(entry.version) || entry.version < 0) {
74
+ throw optionsError(
75
+ `keys[${index}].version must be a non-negative integer`,
76
+ );
77
+ }
78
+ if (seen.has(entry.version)) {
79
+ throw optionsError(
80
+ `keys[${index}].version ${entry.version} is duplicated`,
81
+ );
82
+ }
83
+ seen.add(entry.version);
84
+
85
+ const decoded = decodeBase64Key(entry.value);
86
+ if (decoded.byteLength !== 32) {
87
+ throw optionsError(
88
+ `keys[${index}].value must decode to exactly 32 bytes`,
89
+ );
90
+ }
91
+
92
+ return {
93
+ version: entry.version,
94
+ value: entry.value.trim(),
95
+ };
96
+ });
97
+
98
+ const defaults = {
99
+ ttlMs: options.defaults?.ttlMs ?? DEFAULT_TTL_MS,
100
+ };
101
+ assertNullableNonNegativeInteger(defaults.ttlMs, "defaults.ttlMs");
102
+
103
+ return {
104
+ keys,
105
+ activeVersion: keys[0].version,
106
+ keyVersions: new Map(keys.map((entry) => [entry.version, entry.value])),
107
+ defaults,
108
+ logLevel: normalizeLogLevel(options.logLevel),
109
+ };
110
+ }
@@ -0,0 +1,26 @@
1
+ /// <reference types="vite/client" />
2
+ import { test } from "vitest";
3
+ import { convexTest } from "convex-test";
4
+ export const modules = import.meta.glob("./**/*.*s");
5
+
6
+ import {
7
+ defineSchema,
8
+ type GenericSchema,
9
+ type SchemaDefinition,
10
+ } from "convex/server";
11
+ import { type ComponentApi } from "../component/_generated/component.js";
12
+ import { componentsGeneric } from "convex/server";
13
+ import { register } from "../test.js";
14
+
15
+ export function initConvexTest<
16
+ Schema extends SchemaDefinition<GenericSchema, boolean>,
17
+ >(schema?: Schema) {
18
+ const t = convexTest(schema ?? defineSchema({}), modules);
19
+ register(t);
20
+ return t;
21
+ }
22
+ export const components = componentsGeneric() as unknown as {
23
+ secretStore: ComponentApi;
24
+ };
25
+
26
+ test("setup", () => {});