@devries-cameron20 / t3code Mirror · read-only
Fork 0

The best way to control Claude Code, Codex and more from any computer or phone

Mirrored from https://github.com/Camo67/t3code.git

Synced Nov 21, 06:00 UTC

main
ts 660 lines 22.3 KB
Raw
1 import * as kms from "@distilled.cloud/gcp/cloudkms_v1";
2 import { isResolved } from "alchemy/Diff";
3 import { createPhysicalName } from "alchemy/PhysicalName";
4 import * as Provider from "alchemy/Provider";
5 import { Resource } from "alchemy/Resource";
6 import * as Data from "effect/Data";
7 import * as Effect from "effect/Effect";
8 import * as Schedule from "effect/Schedule";
9 import { GcpEnvironment } from "../Environment.ts";
10 import { waitForOperation as waitForGcpOperation } from "../Operation.ts";
11 import type { Providers } from "../Providers.ts";
12
13 const MAX_NAME_LENGTH = 63;
14
15 export type SingleTenantHsmAddQuorumMember = {
16 /**
17 * PEM-encoded RSA-2048 public key of the 2FA key for the new quorum
18 * member.
19 */
20 twoFactorPublicKeyPem?: string;
21 };
22
23 export type SingleTenantHsmRemoveQuorumMember = {
24 /**
25 * PEM-encoded RSA-2048 public key of the 2FA key to remove.
26 */
27 twoFactorPublicKeyPem?: string;
28 };
29
30 export type SingleTenantHsmRegisterTwoFactorAuthKeys = {
31 /**
32 * PEM-encoded RSA-2048 public keys for M-of-N quorum auth.
33 */
34 twoFactorPublicKeyPems?: string[];
35 /**
36 * Required approver count (M). Must be `>= 2` and
37 * `<= totalApproverCount - 1`.
38 */
39 requiredApproverCount?: number;
40 };
41
42 export type SingleTenantHsmInstanceProposalProps = {
43 /**
44 * Parent SingleTenantHsmInstance. Full name
45 * `projects/{project}/locations/{location}/singleTenantHsmInstances/{instance}`
46 * or the instance id (combined with `location`). Immutable — changing
47 * it replaces the proposal.
48 */
49 singleTenantHsmInstance: string;
50 /**
51 * Cloud KMS location (`us-central1`, `global`, `us`, …). Used when
52 * `singleTenantHsmInstance` is a bare id. Immutable — changing it
53 * replaces the proposal. `US-CENTRAL1` is accepted and normalized to
54 * `us-central1`.
55 * @default the stack's GCP region (`GCP.Region`, profile region, `us-central1`)
56 */
57 location?: string;
58 /**
59 * Proposal id (the last path segment). If omitted, a unique name is
60 * generated from the stack, stage, and logical id. Must match
61 * `[a-zA-Z0-9_-]{1,63}`. Immutable — changing it replaces the
62 * proposal.
63 */
64 proposalId?: string;
65 /**
66 * Time-to-live for the proposal (e.g. `"3600s"`). Input-only.
67 * Proposals expire after this duration. Immutable.
68 */
69 ttl?: string;
70 /**
71 * Refresh the instance so it stays active. Mutually exclusive with
72 * the other operation fields. Immutable.
73 */
74 refreshSingleTenantHsmInstance?: boolean;
75 /**
76 * Enable a DISABLED instance. Mutually exclusive with the other
77 * operation fields. Immutable.
78 */
79 enableSingleTenantHsmInstance?: boolean;
80 /**
81 * Disable an ACTIVE instance. Mutually exclusive with the other
82 * operation fields. Immutable.
83 */
84 disableSingleTenantHsmInstance?: boolean;
85 /**
86 * Delete the instance. Mutually exclusive with the other operation
87 * fields. Immutable.
88 */
89 deleteSingleTenantHsmInstance?: boolean;
90 /**
91 * Add a quorum member. Mutually exclusive with the other operation
92 * fields. Immutable.
93 */
94 addQuorumMember?: SingleTenantHsmAddQuorumMember;
95 /**
96 * Remove a quorum member. Mutually exclusive with the other
97 * operation fields. Immutable.
98 */
99 removeQuorumMember?: SingleTenantHsmRemoveQuorumMember;
100 /**
101 * Register 2FA keys to finish instance setup. Required while the
102 * instance is `PENDING_TWO_FACTOR_AUTH_REGISTRATION`. Mutually
103 * exclusive with the other operation fields. Immutable.
104 */
105 registerTwoFactorAuthKeys?: SingleTenantHsmRegisterTwoFactorAuthKeys;
106 };
107
108 export type SingleTenantHsmInstanceProposalAttrs = {
109 /** Full resource name `projects/.../proposals/{proposal}`. */
110 name: string;
111 /** Proposal id (last path segment). */
112 proposalId: string;
113 /** Parent SingleTenantHsmInstance resource name. */
114 singleTenantHsmInstance: string;
115 /** Location id (`us-central1`, `global`, …). */
116 location: string;
117 /** Project id. */
118 project: string;
119 /** Current proposal state. */
120 state: string | undefined;
121 /** RFC3339 creation timestamp. */
122 createTime: string | undefined;
123 /** RFC3339 expiration timestamp. */
124 expireTime: string | undefined;
125 /** RFC3339 deletion timestamp, if soft-deleted. */
126 deleteTime: string | undefined;
127 /** RFC3339 purge timestamp, if `state` is `DELETED`. */
128 purgeTime: string | undefined;
129 /** Failure reason, if `state` is `FAILED`. */
130 failureReason: string | undefined;
131 /** Whether this proposal refreshes the instance. */
132 refreshSingleTenantHsmInstance: boolean;
133 /** Whether this proposal enables the instance. */
134 enableSingleTenantHsmInstance: boolean;
135 /** Whether this proposal disables the instance. */
136 disableSingleTenantHsmInstance: boolean;
137 /** Whether this proposal deletes the instance. */
138 deleteSingleTenantHsmInstance: boolean;
139 /** Add-quorum-member payload, if any. */
140 addQuorumMember: SingleTenantHsmAddQuorumMember | undefined;
141 /** Remove-quorum-member payload, if any. */
142 removeQuorumMember: SingleTenantHsmRemoveQuorumMember | undefined;
143 /** Register-2FA payload, if any. */
144 registerTwoFactorAuthKeys: SingleTenantHsmRegisterTwoFactorAuthKeys | undefined;
145 };
146
147 export type SingleTenantHsmInstanceProposal = Resource<
148 "GCP.KMS.SingleTenantHsmInstanceProposal",
149 SingleTenantHsmInstanceProposalProps,
150 SingleTenantHsmInstanceProposalAttrs,
151 never,
152 Providers
153 >;
154
155 /**
156 * A Cloud KMS SingleTenantHsmInstanceProposal — a quorum-gated operation
157 * on a single-tenant HSM instance (refresh, enable, disable, delete,
158 * register 2FA keys, add/remove quorum members).
159 *
160 * Parent instance, location, id, TTL, and the chosen operation are
161 * identity (changing them replaces the proposal). Cloud KMS has no
162 * update API. Proposals have no labels, so `list` returns every proposal
163 * under listed instances. Single-tenant HSM is entitlement-gated.
164 *
165 * ### Creating a Proposal
166 * **Example:** Refresh an instance
167 * ```typescript
168 * const proposal = yield* GCP.KMS.SingleTenantHsmInstanceProposal(
169 * "Refresh",
170 * {
171 * singleTenantHsmInstance: instanceName,
172 * refreshSingleTenantHsmInstance: true,
173 * },
174 * );
175 * ```
176 *
177 * **Example:** Register 2FA keys
178 * ```typescript
179 * const proposal = yield* GCP.KMS.SingleTenantHsmInstanceProposal(
180 * "Register",
181 * {
182 * singleTenantHsmInstance: instanceName,
183 * registerTwoFactorAuthKeys: {
184 * twoFactorPublicKeyPems: [pemA, pemB, pemC],
185 * requiredApproverCount: 2,
186 * },
187 * },
188 * );
189 * ```
190 *
191 * @resource
192 * @category KMS
193 */
194 export const SingleTenantHsmInstanceProposal = Resource<SingleTenantHsmInstanceProposal>(
195 "GCP.KMS.SingleTenantHsmInstanceProposal",
196 );
197
198 export class SingleTenantHsmInstanceProposalNotResolved extends Data.TaggedError(
199 "GCP.KMS.SingleTenantHsmInstanceProposalNotResolved",
200 )<{
201 resourceName: string;
202 }> {}
203
204 export class SingleTenantHsmInstanceProposalOperationFailed extends Data.TaggedError(
205 "GCP.KMS.SingleTenantHsmInstanceProposalOperationFailed",
206 )<{
207 operation: string;
208 message: string;
209 }> {}
210
211 export class SingleTenantHsmInstanceProposalPending extends Data.TaggedError(
212 "GCP.KMS.SingleTenantHsmInstanceProposalPending",
213 )<{
214 resourceName: string;
215 state: string;
216 }> {}
217
218 const lastSegment = (value: string) => {
219 const trimmed = value.replace(/\/+$/, "");
220 const parts = trimmed.split("/");
221 return parts[parts.length - 1] || trimmed;
222 };
223
224 const normalizeLocation = (location: string | undefined, fallback: string) =>
225 lastSegment(location ?? fallback).toLowerCase();
226
227 const parseName = (name: string, fallbackLocation: string) => {
228 const parts = name.split("/").filter((part) => part.length > 0);
229 const proposalsAt = parts.lastIndexOf("proposals");
230 const instancesAt = parts.lastIndexOf("singleTenantHsmInstances");
231 const locationsAt = parts.lastIndexOf("locations");
232 const projectsAt = parts.lastIndexOf("projects");
233 const instance = instancesAt >= 0 ? parts.slice(0, instancesAt + 2).join("/") : "";
234 return {
235 project: projectsAt >= 0 && parts[projectsAt + 1] ? parts[projectsAt + 1]! : "",
236 location:
237 locationsAt >= 0 && parts[locationsAt + 1] ? parts[locationsAt + 1]! : fallbackLocation,
238 singleTenantHsmInstance: instance,
239 proposalId:
240 proposalsAt >= 0 && parts[proposalsAt + 1] ? parts[proposalsAt + 1]! : lastSegment(name),
241 };
242 };
243
244 const resolveParent = (
245 project: string,
246 instance: string,
247 location: string | undefined,
248 region: string,
249 ) => {
250 if (instance.includes("/")) {
251 const parsed = parseName(
252 instance.includes("/proposals/") ? instance : `${instance}/proposals/_`,
253 region,
254 );
255 return {
256 parent: parsed.singleTenantHsmInstance,
257 location: parsed.location,
258 project: parsed.project || project,
259 };
260 }
261 const loc = normalizeLocation(location, region);
262 return {
263 parent: `projects/${project}/locations/${loc}/singleTenantHsmInstances/${instance}`,
264 location: loc,
265 project,
266 };
267 };
268
269 const resourceName = (parent: string, proposalId: string) => `${parent}/proposals/${proposalId}`;
270
271 const toId = (id: string, proposalId: string | undefined, existing?: string) =>
272 Effect.gen(function* () {
273 return (
274 proposalId ??
275 existing ??
276 (yield* createPhysicalName({
277 id,
278 maxLength: MAX_NAME_LENGTH,
279 lowercase: true,
280 }))
281 );
282 });
283
284 const present = (value: unknown) => value !== undefined && value !== false;
285
286 const toAttrs = (
287 proposal: kms.SingleTenantHsmInstanceProposal,
288 project: string,
289 region: string,
290 ): SingleTenantHsmInstanceProposalAttrs => {
291 const name = proposal.name ?? "";
292 const parsed = parseName(name, region);
293 return {
294 name,
295 proposalId: parsed.proposalId,
296 singleTenantHsmInstance: parsed.singleTenantHsmInstance,
297 location: parsed.location,
298 project: parsed.project || project,
299 state: proposal.state,
300 createTime: proposal.createTime,
301 expireTime: proposal.expireTime,
302 deleteTime: proposal.deleteTime,
303 purgeTime: proposal.purgeTime,
304 failureReason: proposal.failureReason,
305 refreshSingleTenantHsmInstance: present(proposal.refreshSingleTenantHsmInstance),
306 enableSingleTenantHsmInstance: present(proposal.enableSingleTenantHsmInstance),
307 disableSingleTenantHsmInstance: present(proposal.disableSingleTenantHsmInstance),
308 deleteSingleTenantHsmInstance: present(proposal.deleteSingleTenantHsmInstance),
309 addQuorumMember: proposal.addQuorumMember,
310 removeQuorumMember: proposal.removeQuorumMember,
311 registerTwoFactorAuthKeys: proposal.registerTwoFactorAuthKeys,
312 };
313 };
314
315 const toBody = (
316 news: SingleTenantHsmInstanceProposalProps,
317 ): kms.SingleTenantHsmInstanceProposal => ({
318 ttl: news.ttl,
319 refreshSingleTenantHsmInstance: news.refreshSingleTenantHsmInstance ? {} : undefined,
320 enableSingleTenantHsmInstance: news.enableSingleTenantHsmInstance ? {} : undefined,
321 disableSingleTenantHsmInstance: news.disableSingleTenantHsmInstance ? {} : undefined,
322 deleteSingleTenantHsmInstance: news.deleteSingleTenantHsmInstance ? {} : undefined,
323 addQuorumMember: news.addQuorumMember,
324 removeQuorumMember: news.removeQuorumMember,
325 registerTwoFactorAuthKeys: news.registerTwoFactorAuthKeys,
326 });
327
328 const operationKey = (props: {
329 refreshSingleTenantHsmInstance?: boolean;
330 enableSingleTenantHsmInstance?: boolean;
331 disableSingleTenantHsmInstance?: boolean;
332 deleteSingleTenantHsmInstance?: boolean;
333 addQuorumMember?: SingleTenantHsmAddQuorumMember;
334 removeQuorumMember?: SingleTenantHsmRemoveQuorumMember;
335 registerTwoFactorAuthKeys?: SingleTenantHsmRegisterTwoFactorAuthKeys;
336 }) => {
337 if (props.refreshSingleTenantHsmInstance) return "refresh";
338 if (props.enableSingleTenantHsmInstance) return "enable";
339 if (props.disableSingleTenantHsmInstance) return "disable";
340 if (props.deleteSingleTenantHsmInstance) return "delete";
341 if (props.addQuorumMember !== undefined) {
342 return `add:${props.addQuorumMember.twoFactorPublicKeyPem ?? ""}`;
343 }
344 if (props.removeQuorumMember !== undefined) {
345 return `remove:${props.removeQuorumMember.twoFactorPublicKeyPem ?? ""}`;
346 }
347 if (props.registerTwoFactorAuthKeys !== undefined) {
348 const keys = (props.registerTwoFactorAuthKeys.twoFactorPublicKeyPems ?? [])
349 .slice()
350 .sort()
351 .join(",");
352 return `register:${props.registerTwoFactorAuthKeys.requiredApproverCount ?? ""}:${keys}`;
353 }
354 return "";
355 };
356
357 const getByName = (name: string) =>
358 kms
359 .getProjectsLocationsSingleTenantHsmInstancesProposals({ name })
360 .pipe(Effect.catchTag("NotFound", () => Effect.undefined));
361
362 const paginate = <A, E, R>(
363 fetch: (
364 pageToken: string | undefined,
365 ) => Effect.Effect<{ items: A[]; nextPageToken?: string }, E, R>,
366 ) =>
367 Effect.gen(function* () {
368 const found: A[] = [];
369 let pageToken: string | undefined;
370 for (let page = 0; page < 10; page++) {
371 const response = yield* fetch(pageToken);
372 found.push(...response.items);
373 pageToken = response.nextPageToken;
374 if (pageToken === undefined || pageToken === "") break;
375 }
376 return found;
377 });
378
379 const listInstancesAt = (parent: string) =>
380 paginate((pageToken) =>
381 kms
382 .listProjectsLocationsSingleTenantHsmInstances({
383 parent,
384 pageSize: 1000,
385 pageToken,
386 })
387 .pipe(
388 Effect.map((response) => ({
389 items: response.singleTenantHsmInstances ?? [],
390 nextPageToken: response.nextPageToken,
391 })),
392 Effect.catchTag("NotFound", () =>
393 Effect.succeed({
394 items: [] as kms.SingleTenantHsmInstance[],
395 nextPageToken: undefined,
396 }),
397 ),
398 ),
399 );
400
401 const listProposalsInInstance = (parent: string) =>
402 paginate((pageToken) =>
403 kms
404 .listProjectsLocationsSingleTenantHsmInstancesProposals({
405 parent,
406 pageSize: 1000,
407 pageToken,
408 })
409 .pipe(
410 Effect.map((response) => ({
411 items: response.singleTenantHsmInstanceProposals ?? [],
412 nextPageToken: response.nextPageToken,
413 })),
414 Effect.catchTag("NotFound", () =>
415 Effect.succeed({
416 items: [] as kms.SingleTenantHsmInstanceProposal[],
417 nextPageToken: undefined,
418 }),
419 ),
420 ),
421 );
422
423 const listProposalsAt = (locationParent: string) =>
424 Effect.gen(function* () {
425 const instances = yield* listInstancesAt(locationParent);
426 const pages = yield* Effect.forEach(
427 instances,
428 (instance) =>
429 instance.name
430 ? listProposalsInInstance(instance.name)
431 : Effect.succeed([] as kms.SingleTenantHsmInstanceProposal[]),
432 { concurrency: 4 },
433 );
434 return pages.flat();
435 });
436
437 const waitOperation = (operation: kms.Operation) =>
438 waitForGcpOperation(operation, (name) => kms.getProjectsLocationsOperations({ name }), {
439 budget: "10 minutes",
440 }).pipe(
441 // Re-read the finished operation for its typed response.
442 Effect.flatMap(() =>
443 operation.name === undefined
444 ? Effect.succeed(operation)
445 : kms.getProjectsLocationsOperations({ name: operation.name }),
446 ),
447 );
448
449 const waitReady = (
450 name: string,
451 ): Effect.Effect<
452 kms.SingleTenantHsmInstanceProposal,
453 | SingleTenantHsmInstanceProposalNotResolved
454 | SingleTenantHsmInstanceProposalPending
455 | kms.GetProjectsLocationsSingleTenantHsmInstancesProposalsError,
456 kms.GcpOpContext
457 > => {
458 const probe: Effect.Effect<
459 kms.SingleTenantHsmInstanceProposal,
460 | SingleTenantHsmInstanceProposalNotResolved
461 | SingleTenantHsmInstanceProposalPending
462 | kms.GetProjectsLocationsSingleTenantHsmInstancesProposalsError,
463 kms.GcpOpContext
464 > = getByName(name).pipe(
465 Effect.flatMap(
466 (
467 proposal,
468 ): Effect.Effect<
469 kms.SingleTenantHsmInstanceProposal,
470 SingleTenantHsmInstanceProposalNotResolved | SingleTenantHsmInstanceProposalPending
471 > => {
472 if (proposal === undefined) {
473 return Effect.fail(
474 new SingleTenantHsmInstanceProposalNotResolved({ resourceName: name }),
475 );
476 }
477 if (proposal.state === "CREATING") {
478 return Effect.fail(
479 new SingleTenantHsmInstanceProposalPending({
480 resourceName: name,
481 state: proposal.state,
482 }),
483 );
484 }
485 return Effect.succeed(proposal);
486 },
487 ),
488 );
489 return probe.pipe(
490 Effect.retry({
491 while: (error) => error._tag === "GCP.KMS.SingleTenantHsmInstanceProposalPending",
492 times: 8,
493 schedule: Schedule.spaced("500 millis"),
494 }),
495 );
496 };
497
498 const nameFromOperation = (operation: kms.Operation) => {
499 const response = operation.response;
500 const value = response?.name;
501 return typeof value === "string" && value.length > 0 ? value : undefined;
502 };
503
504 export const SingleTenantHsmInstanceProposalProvider = () =>
505 Provider.succeed(SingleTenantHsmInstanceProposal, {
506 stables: ["name", "proposalId", "singleTenantHsmInstance", "location", "project", "createTime"],
507
508 diff: Effect.fn(function* ({ news, olds, output }) {
509 if (!isResolved(news)) return undefined;
510 const env = yield* GcpEnvironment.current;
511
512 const previousId = olds?.proposalId ?? output?.proposalId;
513 const nextId = news.proposalId ?? previousId;
514 const idChanged = previousId !== undefined && nextId !== undefined && nextId !== previousId;
515
516 const previousParent =
517 output?.singleTenantHsmInstance ??
518 (olds?.singleTenantHsmInstance
519 ? resolveParent("", olds.singleTenantHsmInstance, olds.location, env.region).parent
520 : undefined);
521 const nextParent = resolveParent(
522 output?.project ?? "",
523 news.singleTenantHsmInstance,
524 news.location ?? output?.location,
525 env.region,
526 ).parent;
527 const parentChanged = previousParent !== undefined && previousParent !== nextParent;
528
529 const previousOp = operationKey({
530 refreshSingleTenantHsmInstance:
531 olds?.refreshSingleTenantHsmInstance ?? output?.refreshSingleTenantHsmInstance,
532 enableSingleTenantHsmInstance:
533 olds?.enableSingleTenantHsmInstance ?? output?.enableSingleTenantHsmInstance,
534 disableSingleTenantHsmInstance:
535 olds?.disableSingleTenantHsmInstance ?? output?.disableSingleTenantHsmInstance,
536 deleteSingleTenantHsmInstance:
537 olds?.deleteSingleTenantHsmInstance ?? output?.deleteSingleTenantHsmInstance,
538 addQuorumMember: olds?.addQuorumMember ?? output?.addQuorumMember,
539 removeQuorumMember: olds?.removeQuorumMember ?? output?.removeQuorumMember,
540 registerTwoFactorAuthKeys:
541 olds?.registerTwoFactorAuthKeys ?? output?.registerTwoFactorAuthKeys,
542 });
543 const nextOp = operationKey(news);
544 const operationChanged = previousOp.length > 0 && nextOp.length > 0 && previousOp !== nextOp;
545
546 if (!idChanged && !parentChanged && !operationChanged) {
547 return undefined;
548 }
549 return { action: "replace" as const, deleteFirst: false };
550 }),
551
552 read: Effect.fn(function* ({ id, olds, output }) {
553 const env = yield* GcpEnvironment.current;
554 const proposalId = yield* toId(id, olds?.proposalId, output?.proposalId);
555 const name =
556 output?.name ??
557 (olds?.singleTenantHsmInstance || output?.singleTenantHsmInstance
558 ? resourceName(
559 resolveParent(
560 env.project,
561 olds?.singleTenantHsmInstance ?? output?.singleTenantHsmInstance ?? "",
562 olds?.location ?? output?.location,
563 env.region,
564 ).parent,
565 proposalId,
566 )
567 : undefined);
568 if (name === undefined) return undefined;
569 const existing = yield* getByName(name);
570 if (existing === undefined) return undefined;
571 // Proposals have no labels. Existence at the computed name is
572 // ownership.
573 return toAttrs(existing, env.project, env.region);
574 }),
575
576 list: () =>
577 Effect.gen(function* () {
578 const env = yield* GcpEnvironment.current;
579 const found: SingleTenantHsmInstanceProposalAttrs[] = [];
580 let pageToken: string | undefined;
581 for (let page = 0; page < 10; page++) {
582 const response = yield* kms.listProjectsLocations({
583 name: `projects/${env.project}`,
584 pageSize: 100,
585 pageToken,
586 });
587 const parents = (response.locations ?? [])
588 .map((location) => location.name)
589 .filter((name): name is string => !!name);
590 const batches = yield* Effect.forEach(parents, (parent) => listProposalsAt(parent), {
591 concurrency: 4,
592 });
593 for (const proposals of batches) {
594 for (const proposal of proposals) {
595 found.push(toAttrs(proposal, env.project, env.region));
596 }
597 }
598 pageToken = response.nextPageToken;
599 if (pageToken === undefined || pageToken === "") break;
600 }
601 return found;
602 }),
603
604 reconcile: Effect.fn(function* ({ id, news, output }) {
605 const env = yield* GcpEnvironment.current;
606 const proposalId = yield* toId(id, news.proposalId, output?.proposalId);
607 const parent = resolveParent(
608 env.project,
609 news.singleTenantHsmInstance,
610 news.location ?? output?.location,
611 env.region,
612 );
613 const name = resourceName(parent.parent, proposalId);
614
615 let current = yield* getByName(name);
616
617 if (current === undefined) {
618 const created = yield* kms
619 .createProjectsLocationsSingleTenantHsmInstancesProposals({
620 parent: parent.parent,
621 singleTenantHsmInstanceProposalId: proposalId,
622 body: toBody(news),
623 })
624 .pipe(
625 Effect.flatMap((operation) =>
626 waitOperation(operation).pipe(Effect.map((done) => nameFromOperation(done) ?? name)),
627 ),
628 Effect.flatMap((resolved) => getByName(resolved)),
629 Effect.catchTag("Conflict", () => getByName(name)),
630 );
631 current = created ?? undefined;
632 }
633
634 if (current === undefined) {
635 return yield* new SingleTenantHsmInstanceProposalNotResolved({
636 resourceName: name,
637 });
638 }
639
640 if (current.state === "CREATING") {
641 current = yield* waitReady(current.name ?? name);
642 }
643
644 return toAttrs(current, env.project, env.region);
645 }),
646
647 delete: Effect.fn(function* ({ output }) {
648 yield* kms
649 .deleteProjectsLocationsSingleTenantHsmInstancesProposals({
650 name: output.name,
651 })
652 .pipe(
653 Effect.catchTags({
654 NotFound: () => Effect.void,
655 BadRequest: () => Effect.void,
656 Conflict: () => Effect.void,
657 }),
658 );
659 }),
660 });