@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, 04:45 UTC

main
ts 491 lines 18 KB
Raw
1 import * as lf from "@distilled.cloud/aws/lakeformation";
2 import { isResolved } from "alchemy/Diff";
3 import * as Provider from "alchemy/Provider";
4 import { Resource } from "alchemy/Resource";
5 import * as Effect from "effect/Effect";
6 import { AWSEnvironment } from "../Environment.ts";
7 import type { Providers } from "../Providers.ts";
8 import { retryWhileInvalidPrincipal } from "./internal.ts";
9
10 /**
11 * A principal/permissions pair used for database and table default
12 * permissions.
13 */
14 export interface DefaultPermissionSpec {
15 /**
16 * The principal (IAM ARN or the `IAM_ALLOWED_PRINCIPALS` group).
17 */
18 principal: string;
19 /**
20 * The permissions granted by default (e.g. `["ALL"]`).
21 */
22 permissions: lf.Permission[];
23 }
24
25 export interface DataLakeSettingsProps {
26 /**
27 * Principals to ensure are Lake Formation data lake administrators.
28 * Managed additively: admins that already existed (or were added out of
29 * band) are preserved; on destroy only the admins this resource added are
30 * removed.
31 */
32 dataLakeAdmins?: string[];
33 /**
34 * Principals to ensure are read-only administrators. Managed additively,
35 * like `dataLakeAdmins`.
36 */
37 readOnlyAdmins?: string[];
38 /**
39 * Default permissions applied to newly created databases. The prior value
40 * is captured on first management and restored on destroy.
41 */
42 createDatabaseDefaultPermissions?: DefaultPermissionSpec[];
43 /**
44 * Default permissions applied to newly created tables. The prior value is
45 * captured on first management and restored on destroy.
46 */
47 createTableDefaultPermissions?: DefaultPermissionSpec[];
48 /**
49 * Key/value parameters on the data lake settings (e.g.
50 * `CROSS_ACCOUNT_VERSION`). Captured and restored like the default
51 * permissions.
52 */
53 parameters?: Record<string, string>;
54 /**
55 * Account IDs whose resource shares are trusted.
56 */
57 trustedResourceOwners?: string[];
58 /**
59 * Allow external engines (EMR etc.) to filter data with Lake Formation
60 * permissions.
61 */
62 allowExternalDataFiltering?: boolean;
63 /**
64 * Allow external engines full table access without session tags.
65 */
66 allowFullTableExternalDataAccess?: boolean;
67 /**
68 * Principals allowed to use external data filtering.
69 */
70 externalDataFilteringAllowList?: string[];
71 /**
72 * Session tag values authorized for external data filtering.
73 */
74 authorizedSessionTagValueList?: string[];
75 /**
76 * The catalog id (AWS account id) the settings apply to. Changing it
77 * replaces the resource.
78 * @default the caller's account
79 */
80 catalogId?: string;
81 }
82
83 /** Prop names whose prior values are captured and restored on destroy. */
84 export type ManagedField =
85 | "createDatabaseDefaultPermissions"
86 | "createTableDefaultPermissions"
87 | "parameters"
88 | "trustedResourceOwners"
89 | "allowExternalDataFiltering"
90 | "allowFullTableExternalDataAccess"
91 | "externalDataFilteringAllowList"
92 | "authorizedSessionTagValueList";
93
94 export interface DataLakeSettings extends Resource<
95 "AWS.LakeFormation.DataLakeSettings",
96 DataLakeSettingsProps,
97 {
98 catalogId: string;
99 dataLakeAdmins: string[];
100 readOnlyAdmins: string[];
101 managedAdmins: string[];
102 managedReadOnlyAdmins: string[];
103 managedFields: ManagedField[];
104 captured: lf.DataLakeSettings;
105 /**
106 * The live value of every field in `managedFields`, as observed. Lets
107 * `alchemy drift` detect out-of-band changes.
108 */
109 managedSettings?: Partial<Record<ManagedField, unknown>>;
110 },
111 {},
112 Providers
113 > {}
114
115 /**
116 * The Lake Formation data lake settings for the account — an account/region
117 * singleton controlling who the data lake administrators are, the default
118 * permissions for new databases/tables, and external data filtering.
119 *
120 * The resource is capture-and-restore: the pre-existing settings are
121 * snapshotted the first time it reconciles, admin lists are managed
122 * additively (existing admins are never removed), and destroy puts back what
123 * was there before for everything this resource managed.
124 *
125 * ### Managing Administrators
126 * **Example:** Add a Data Lake Administrator
127 * ```typescript
128 * import * as AWS from "@alchemy.run/aws";
129 *
130 * const settings = yield* AWS.LakeFormation.DataLakeSettings("Settings", {
131 * dataLakeAdmins: [adminRole.roleArn],
132 * });
133 * ```
134 *
135 * ### Default Permissions
136 * **Example:** Disable IAM-Allowed-Principals Defaults
137 * ```typescript
138 * const settings = yield* AWS.LakeFormation.DataLakeSettings("Settings", {
139 * dataLakeAdmins: [adminRole.roleArn],
140 * createDatabaseDefaultPermissions: [],
141 * createTableDefaultPermissions: [],
142 * });
143 * ```
144 *
145 * @resource
146 */
147 export const DataLakeSettings = Resource<DataLakeSettings>("AWS.LakeFormation.DataLakeSettings");
148
149 const principalIds = (principals: lf.DataLakePrincipal[] | undefined): string[] =>
150 (principals ?? [])
151 .map((p) => p.DataLakePrincipalIdentifier)
152 .filter((id): id is string => id !== undefined);
153
154 const toPrincipals = (ids: string[]): lf.DataLakePrincipal[] =>
155 ids.map((id) => ({ DataLakePrincipalIdentifier: id }));
156
157 const toWireDefaults = (specs: DefaultPermissionSpec[]): lf.PrincipalPermissions[] =>
158 specs.map((s) => ({
159 Principal: { DataLakePrincipalIdentifier: s.principal },
160 Permissions: s.permissions,
161 }));
162
163 const dedupe = (values: string[]): string[] => [...new Set(values)];
164
165 /**
166 * Stable fingerprint of the aspects of the settings this resource manages —
167 * used to skip the `PutDataLakeSettings` call when nothing changed.
168 */
169 const fingerprint = (s: lf.DataLakeSettings): string =>
170 JSON.stringify({
171 admins: principalIds(s.DataLakeAdmins).sort(),
172 readOnlyAdmins: principalIds(s.ReadOnlyAdmins).sort(),
173 createDb: (s.CreateDatabaseDefaultPermissions ?? []).map((p) => ({
174 principal: p.Principal?.DataLakePrincipalIdentifier,
175 permissions: [...(p.Permissions ?? [])].sort(),
176 })),
177 createTable: (s.CreateTableDefaultPermissions ?? []).map((p) => ({
178 principal: p.Principal?.DataLakePrincipalIdentifier,
179 permissions: [...(p.Permissions ?? [])].sort(),
180 })),
181 parameters: Object.entries(s.Parameters ?? {}).sort(([a], [b]) => a.localeCompare(b)),
182 trusted: [...(s.TrustedResourceOwners ?? [])].sort(),
183 allowExternal: s.AllowExternalDataFiltering ?? false,
184 allowFullTable: s.AllowFullTableExternalDataAccess ?? false,
185 allowList: principalIds(s.ExternalDataFilteringAllowList).sort(),
186 sessionTags: [...(s.AuthorizedSessionTagValueList ?? [])].sort(),
187 });
188
189 /**
190 * The live value of each managed field, normalized for comparison. `read`
191 * and `reconcile` share it so converged settings read unchanged.
192 */
193 const observeManagedSettings = (
194 s: lf.DataLakeSettings,
195 fields: readonly ManagedField[],
196 ): Partial<Record<ManagedField, unknown>> => {
197 const defaults = (permissions: lf.PrincipalPermissions[] | undefined) =>
198 (permissions ?? [])
199 .map((p) => ({
200 principal: p.Principal?.DataLakePrincipalIdentifier,
201 permissions: [...(p.Permissions ?? [])].sort(),
202 }))
203 .sort((a, b) => (a.principal ?? "").localeCompare(b.principal ?? ""));
204 const value = (field: ManagedField): unknown => {
205 switch (field) {
206 case "createDatabaseDefaultPermissions":
207 return defaults(s.CreateDatabaseDefaultPermissions);
208 case "createTableDefaultPermissions":
209 return defaults(s.CreateTableDefaultPermissions);
210 case "parameters":
211 return Object.fromEntries(
212 Object.entries(s.Parameters ?? {}).filter(([, v]) => v !== undefined),
213 );
214 case "trustedResourceOwners":
215 return [...(s.TrustedResourceOwners ?? [])].sort();
216 case "allowExternalDataFiltering":
217 return s.AllowExternalDataFiltering ?? false;
218 case "allowFullTableExternalDataAccess":
219 return s.AllowFullTableExternalDataAccess ?? false;
220 case "externalDataFilteringAllowList":
221 return principalIds(s.ExternalDataFilteringAllowList).sort();
222 case "authorizedSessionTagValueList":
223 return [...(s.AuthorizedSessionTagValueList ?? [])].sort();
224 }
225 };
226 return Object.fromEntries(fields.map((field) => [field, value(field)]));
227 };
228
229 /** Plain JSON snapshot of the observed settings for capture-and-restore. */
230 const snapshot = (s: lf.DataLakeSettings): lf.DataLakeSettings =>
231 JSON.parse(JSON.stringify(s)) as lf.DataLakeSettings;
232
233 const MANAGED_FIELDS: ManagedField[] = [
234 "createDatabaseDefaultPermissions",
235 "createTableDefaultPermissions",
236 "parameters",
237 "trustedResourceOwners",
238 "allowExternalDataFiltering",
239 "allowFullTableExternalDataAccess",
240 "externalDataFilteringAllowList",
241 "authorizedSessionTagValueList",
242 ];
243
244 /** Copy one managed field's wire value from `source` onto `target`. */
245 const copyField = (
246 target: lf.DataLakeSettings,
247 source: lf.DataLakeSettings,
248 field: ManagedField,
249 ): void => {
250 switch (field) {
251 case "createDatabaseDefaultPermissions":
252 target.CreateDatabaseDefaultPermissions = source.CreateDatabaseDefaultPermissions;
253 break;
254 case "createTableDefaultPermissions":
255 target.CreateTableDefaultPermissions = source.CreateTableDefaultPermissions;
256 break;
257 case "parameters":
258 target.Parameters = source.Parameters;
259 break;
260 case "trustedResourceOwners":
261 target.TrustedResourceOwners = source.TrustedResourceOwners;
262 break;
263 case "allowExternalDataFiltering":
264 target.AllowExternalDataFiltering = source.AllowExternalDataFiltering;
265 break;
266 case "allowFullTableExternalDataAccess":
267 target.AllowFullTableExternalDataAccess = source.AllowFullTableExternalDataAccess;
268 break;
269 case "externalDataFilteringAllowList":
270 target.ExternalDataFilteringAllowList = source.ExternalDataFilteringAllowList;
271 break;
272 case "authorizedSessionTagValueList":
273 target.AuthorizedSessionTagValueList = source.AuthorizedSessionTagValueList;
274 break;
275 }
276 };
277
278 /** Apply a desired prop value for one managed field onto `target`. */
279 const applyField = (
280 target: lf.DataLakeSettings,
281 news: DataLakeSettingsProps,
282 field: ManagedField,
283 ): void => {
284 switch (field) {
285 case "createDatabaseDefaultPermissions":
286 target.CreateDatabaseDefaultPermissions = toWireDefaults(
287 news.createDatabaseDefaultPermissions!,
288 );
289 break;
290 case "createTableDefaultPermissions":
291 target.CreateTableDefaultPermissions = toWireDefaults(news.createTableDefaultPermissions!);
292 break;
293 case "parameters":
294 target.Parameters = news.parameters;
295 break;
296 case "trustedResourceOwners":
297 target.TrustedResourceOwners = news.trustedResourceOwners;
298 break;
299 case "allowExternalDataFiltering":
300 target.AllowExternalDataFiltering = news.allowExternalDataFiltering;
301 break;
302 case "allowFullTableExternalDataAccess":
303 target.AllowFullTableExternalDataAccess = news.allowFullTableExternalDataAccess;
304 break;
305 case "externalDataFilteringAllowList":
306 target.ExternalDataFilteringAllowList = toPrincipals(news.externalDataFilteringAllowList!);
307 break;
308 case "authorizedSessionTagValueList":
309 target.AuthorizedSessionTagValueList = news.authorizedSessionTagValueList;
310 break;
311 }
312 };
313
314 export const DataLakeSettingsProvider = () =>
315 Provider.effect(
316 DataLakeSettings,
317 Effect.gen(function* () {
318 const observe = Effect.fn(function* (catalogId: string | undefined) {
319 const response = yield* lf.getDataLakeSettings({
320 CatalogId: catalogId,
321 });
322 return response.DataLakeSettings ?? {};
323 });
324
325 /**
326 * Merge managed admins into the observed list: keep everything
327 * observed except principals we previously managed and no longer
328 * manage (unless they were admins before we ever touched the
329 * settings), then union with the currently-managed set.
330 */
331 const mergeAdmins = (input: {
332 observed: string[];
333 managed: string[];
334 previouslyManaged: string[];
335 captured: string[];
336 }): string[] => {
337 const removedByUs = input.previouslyManaged.filter((p) => !input.managed.includes(p));
338 return dedupe([
339 ...input.observed.filter((p) => !removedByUs.includes(p) || input.captured.includes(p)),
340 ...input.managed,
341 ]);
342 };
343
344 return DataLakeSettings.Provider.of({
345 stables: ["catalogId"],
346
347 // Account/region singleton — return the single instance.
348 list: () =>
349 Effect.gen(function* () {
350 const observed = yield* observe(undefined);
351 const { accountId } = yield* AWSEnvironment.current;
352 return [
353 {
354 catalogId: accountId,
355 dataLakeAdmins: principalIds(observed.DataLakeAdmins),
356 readOnlyAdmins: principalIds(observed.ReadOnlyAdmins),
357 managedAdmins: [],
358 managedReadOnlyAdmins: [],
359 managedFields: [] as ManagedField[],
360 captured: snapshot(observed),
361 },
362 ];
363 }),
364
365 read: Effect.fn(function* ({ olds, output }) {
366 const { accountId } = yield* AWSEnvironment.current;
367 const catalogId = output?.catalogId ?? olds?.catalogId ?? accountId;
368 const observed = yield* observe(olds?.catalogId);
369 return {
370 catalogId,
371 dataLakeAdmins: principalIds(observed.DataLakeAdmins),
372 readOnlyAdmins: principalIds(observed.ReadOnlyAdmins),
373 managedAdmins: output?.managedAdmins ?? [],
374 managedReadOnlyAdmins: output?.managedReadOnlyAdmins ?? [],
375 managedFields: output?.managedFields ?? [],
376 captured: output?.captured ?? snapshot(observed),
377 managedSettings: observeManagedSettings(observed, output?.managedFields ?? []),
378 };
379 }),
380
381 diff: Effect.fn(function* ({ news, olds }) {
382 if (!isResolved(news)) return undefined;
383 if ((news.catalogId ?? undefined) !== (olds.catalogId ?? undefined)) {
384 return { action: "replace" } as const;
385 }
386 // everything else → update (singleton sync)
387 }),
388
389 reconcile: Effect.fn(function* ({ news, olds, output, session }) {
390 const { accountId } = yield* AWSEnvironment.current;
391 const catalogId = news.catalogId ?? accountId;
392
393 // 1. OBSERVE — cloud settings are authoritative; capture the
394 // pre-existing settings the first time we manage them.
395 const observed = yield* observe(news.catalogId);
396 const captured = output?.captured ?? snapshot(observed);
397
398 // 2. SYNC — start from observed, overlay the aspects we manage.
399 const desired = snapshot(observed);
400
401 const managedAdmins = news.dataLakeAdmins ?? [];
402 const managedReadOnlyAdmins = news.readOnlyAdmins ?? [];
403 desired.DataLakeAdmins = toPrincipals(
404 mergeAdmins({
405 observed: principalIds(observed.DataLakeAdmins),
406 managed: managedAdmins,
407 previouslyManaged: olds?.dataLakeAdmins ?? [],
408 captured: principalIds(captured.DataLakeAdmins),
409 }),
410 );
411 desired.ReadOnlyAdmins = toPrincipals(
412 mergeAdmins({
413 observed: principalIds(observed.ReadOnlyAdmins),
414 managed: managedReadOnlyAdmins,
415 previouslyManaged: olds?.readOnlyAdmins ?? [],
416 captured: principalIds(captured.ReadOnlyAdmins),
417 }),
418 );
419
420 const managedFields = MANAGED_FIELDS.filter((field) => news[field] !== undefined);
421 for (const field of MANAGED_FIELDS) {
422 if (news[field] !== undefined) {
423 applyField(desired, news, field);
424 } else if (olds?.[field] !== undefined) {
425 // field was managed before and is no longer — restore the
426 // captured pre-management value.
427 copyField(desired, captured, field);
428 }
429 }
430
431 if (fingerprint(desired) !== fingerprint(observed)) {
432 yield* lf
433 .putDataLakeSettings({
434 CatalogId: news.catalogId,
435 DataLakeSettings: desired,
436 })
437 .pipe(retryWhileInvalidPrincipal);
438 yield* session.note("Updated data lake settings");
439 }
440
441 return {
442 catalogId,
443 dataLakeAdmins: principalIds(desired.DataLakeAdmins),
444 readOnlyAdmins: principalIds(desired.ReadOnlyAdmins),
445 managedAdmins,
446 managedReadOnlyAdmins,
447 managedFields,
448 captured,
449 managedSettings: observeManagedSettings(desired, managedFields),
450 };
451 }),
452
453 delete: Effect.fn(function* ({ output, session }) {
454 // Restore: remove the admins we added (unless they were already
455 // admins before we managed the settings) and put back the captured
456 // values for every field we managed.
457 const catalogIdInput = output.catalogId === undefined ? undefined : output.catalogId;
458 const observed = yield* observe(catalogIdInput);
459 const captured = output.captured;
460 const desired = snapshot(observed);
461
462 const capturedAdmins = principalIds(captured.DataLakeAdmins);
463 desired.DataLakeAdmins = toPrincipals(
464 principalIds(observed.DataLakeAdmins).filter(
465 (p) => !output.managedAdmins.includes(p) || capturedAdmins.includes(p),
466 ),
467 );
468 const capturedReadOnly = principalIds(captured.ReadOnlyAdmins);
469 desired.ReadOnlyAdmins = toPrincipals(
470 principalIds(observed.ReadOnlyAdmins).filter(
471 (p) => !output.managedReadOnlyAdmins.includes(p) || capturedReadOnly.includes(p),
472 ),
473 );
474
475 for (const field of output.managedFields) {
476 copyField(desired, captured, field);
477 }
478
479 if (fingerprint(desired) !== fingerprint(observed)) {
480 yield* lf
481 .putDataLakeSettings({
482 CatalogId: catalogIdInput,
483 DataLakeSettings: desired,
484 })
485 .pipe(retryWhileInvalidPrincipal);
486 yield* session.note("Restored data lake settings");
487 }
488 }),
489 });
490 }),
491 );