cdk-glue-iceberg-table 0.1.1

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.
@@ -0,0 +1,549 @@
1
+ "use strict";
2
+ Object.defineProperty(exports, "__esModule", { value: true });
3
+ exports.IcebergTable = exports.IcebergNullOrder = exports.IcebergSortDirection = void 0;
4
+ const aws_cdk_lib_1 = require("aws-cdk-lib");
5
+ const aws_glue_1 = require("aws-cdk-lib/aws-glue");
6
+ const aws_iam_1 = require("aws-cdk-lib/aws-iam");
7
+ const iceberg_partition_transform_1 = require("./iceberg-partition-transform");
8
+ const iceberg_table_properties_1 = require("./iceberg-table-properties");
9
+ /// /////////////////////////////////////////////////
10
+ /// /////////////////////////////////////////////////
11
+ // Sort order enums
12
+ /** Sort direction for an Iceberg sort field. */
13
+ var IcebergSortDirection;
14
+ (function (IcebergSortDirection) {
15
+ /** Ascending — smaller values first. */
16
+ IcebergSortDirection["ASC"] = "asc";
17
+ /** Descending — larger values first. */
18
+ IcebergSortDirection["DESC"] = "desc";
19
+ })(IcebergSortDirection || (exports.IcebergSortDirection = IcebergSortDirection = {}));
20
+ /** Null ordering for an Iceberg sort field. */
21
+ var IcebergNullOrder;
22
+ (function (IcebergNullOrder) {
23
+ /** Nulls precede all non-null values. */
24
+ IcebergNullOrder["NULLS_FIRST"] = "nulls-first";
25
+ /** Nulls follow all non-null values. */
26
+ IcebergNullOrder["NULLS_LAST"] = "nulls-last";
27
+ })(IcebergNullOrder || (exports.IcebergNullOrder = IcebergNullOrder = {}));
28
+ /// /////////////////////////////////////////////////
29
+ /// /////////////////////////////////////////////////
30
+ // Grant action sets
31
+ const READ_TABLE_ACTIONS = [
32
+ 'glue:BatchGetPartition',
33
+ 'glue:GetPartition',
34
+ 'glue:GetPartitions',
35
+ 'glue:GetTable',
36
+ 'glue:GetTables',
37
+ 'glue:GetTableVersion',
38
+ 'glue:GetTableVersions',
39
+ ];
40
+ const WRITE_TABLE_ACTIONS = [
41
+ 'glue:BatchCreatePartition',
42
+ 'glue:BatchDeletePartition',
43
+ 'glue:CreatePartition',
44
+ 'glue:DeletePartition',
45
+ 'glue:UpdatePartition',
46
+ 'glue:UpdateTable',
47
+ ];
48
+ /// S3 actions that operate at the bucket level AND support the
49
+ /// `s3:prefix` request condition key (per the S3 docs). Granted on
50
+ /// the bucket ARN with a `StringLike s3:prefix = [<prefix>*, <prefix>]`
51
+ /// condition so the grantee can only list the table's own prefix.
52
+ const READ_S3_LIST_ACTIONS = [
53
+ 's3:ListBucket',
54
+ ];
55
+ /// S3 actions that operate at the bucket level but DO NOT support
56
+ /// `s3:prefix`. Granted on the bucket ARN with no condition — adding
57
+ /// one would silently deny these actions at runtime even though they
58
+ /// appear in the policy document.
59
+ const READ_S3_BUCKET_ACTIONS = [
60
+ 's3:GetBucketLocation',
61
+ ];
62
+ const WRITE_S3_BUCKET_ACTIONS = [
63
+ 's3:ListBucketMultipartUploads',
64
+ ];
65
+ /// S3 actions that operate at the object level. Must be granted on
66
+ /// the `bucket/prefix*` ARN.
67
+ const READ_S3_OBJECT_ACTIONS = [
68
+ 's3:GetObject',
69
+ ];
70
+ const WRITE_S3_OBJECT_ACTIONS = [
71
+ 's3:PutObject',
72
+ 's3:DeleteObject',
73
+ 's3:AbortMultipartUpload',
74
+ 's3:ListMultipartUploadParts',
75
+ ];
76
+ /// /////////////////////////////////////////////////
77
+ /// /////////////////////////////////////////////////
78
+ // IcebergTable
79
+ /**
80
+ * A Glue table created in the Apache Iceberg open table format.
81
+ *
82
+ * The construct emits the
83
+ * `OpenTableFormatInput.IcebergInput.IcebergTableInput` shape that
84
+ * survives CloudFormation `Update` (the alternative — placing columns
85
+ * under `tableInput.storageDescriptor.columns` — silently strips
86
+ * `table_type=ICEBERG` from Glue parameters on the first update and
87
+ * leaves the table un-queryable in Athena).
88
+ */
89
+ class IcebergTable extends aws_cdk_lib_1.Resource {
90
+ /** Glue ARN of the table. */
91
+ tableArn;
92
+ /** Table name as it appears in Glue / Athena. */
93
+ tableName;
94
+ /** Glue database holding the table. */
95
+ database;
96
+ /** S3 URI where the Iceberg metadata + data live. */
97
+ location;
98
+ /** Resolved data format (after defaulting). */
99
+ dataFormat;
100
+ /** Resolved format version (after defaulting). */
101
+ formatVersion;
102
+ /** The underlying L1 — exposed for escape-hatch use. */
103
+ resource;
104
+ bucketArn;
105
+ objectArn;
106
+ s3PrefixGlob;
107
+ constructor(scope, id, props) {
108
+ super(scope, id, {
109
+ physicalName: props.tableName,
110
+ });
111
+ validateProps(props);
112
+ this.database = props.database;
113
+ this.tableName = props.tableName;
114
+ this.location = normalizeLocation(props.location);
115
+ this.dataFormat = props.dataFormat ?? iceberg_table_properties_1.IcebergDataFormat.PARQUET;
116
+ this.formatVersion = props.formatVersion ?? iceberg_table_properties_1.IcebergFormatVersion.V2;
117
+ const parsed = parseS3Uri(this.location);
118
+ this.bucketArn = `arn:${aws_cdk_lib_1.Stack.of(this).partition}:s3:::${parsed.bucket}`;
119
+ this.objectArn = `${this.bucketArn}/${parsed.key}*`;
120
+ this.s3PrefixGlob = `${parsed.key}*`;
121
+ const mergedProperties = mergeProperties(this.dataFormat, this.formatVersion, props.tableProperties, props.comment);
122
+ (0, iceberg_table_properties_1.validateIcebergProperties)(this.dataFormat, this.formatVersion, mergedProperties);
123
+ const rendered = renderSchema(props.columns);
124
+ validatePartitionSpec(props.partitionSpec, rendered.columnByName);
125
+ validateSortOrder(props.sortOrder, rendered.columnByName);
126
+ const identifierFieldIds = resolveIdentifierFieldIds(props.identifierFieldNames, rendered.columnByName);
127
+ this.resource = new aws_glue_1.CfnTable(this, 'Resource', {
128
+ catalogId: aws_cdk_lib_1.Stack.of(this).account,
129
+ databaseName: props.database.databaseName,
130
+ name: this.tableName,
131
+ openTableFormatInput: {
132
+ icebergInput: {
133
+ metadataOperation: 'CREATE',
134
+ version: this.formatVersion,
135
+ icebergTableInput: {
136
+ location: this.location,
137
+ schema: {
138
+ type: 'struct',
139
+ schemaId: 0,
140
+ fields: rendered.fields,
141
+ identifierFieldIds: identifierFieldIds,
142
+ },
143
+ partitionSpec: renderPartitionSpec(props.partitionSpec, rendered.columnByName),
144
+ writeOrder: renderSortOrder(props.sortOrder, rendered.columnByName),
145
+ properties: mergedProperties,
146
+ },
147
+ },
148
+ },
149
+ });
150
+ const removalPolicy = props.removalPolicy ?? aws_cdk_lib_1.RemovalPolicy.RETAIN;
151
+ this.resource.applyRemovalPolicy(removalPolicy);
152
+ this.tableArn = aws_cdk_lib_1.Stack.of(this).formatArn({
153
+ service: 'glue',
154
+ resource: 'table',
155
+ resourceName: `${props.database.databaseName}/${this.tableName}`,
156
+ });
157
+ this.node.defaultChild = this.resource;
158
+ }
159
+ /**
160
+ * Import an existing Iceberg table by its name + database.
161
+ *
162
+ * Imported tables can be referenced from grants but cannot be
163
+ * mutated; their schema and properties are unknown to CDK.
164
+ */
165
+ static fromIcebergTableAttributes(scope, id, attrs) {
166
+ const stack = aws_cdk_lib_1.Stack.of(scope);
167
+ const location = normalizeLocation(attrs.location);
168
+ const parsed = parseS3Uri(location);
169
+ const bucketArn = `arn:${stack.partition}:s3:::${parsed.bucket}`;
170
+ const objectArn = `${bucketArn}/${parsed.key}*`;
171
+ const prefixGlob = `${parsed.key}*`;
172
+ const tableArn = stack.formatArn({
173
+ service: 'glue',
174
+ resource: 'table',
175
+ resourceName: `${attrs.database.databaseName}/${attrs.tableName}`,
176
+ });
177
+ class Imported extends aws_cdk_lib_1.Resource {
178
+ tableArn = tableArn;
179
+ tableName = attrs.tableName;
180
+ database = attrs.database;
181
+ location = location;
182
+ grantRead(grantee) {
183
+ return grantSplit(grantee, {
184
+ tableArn,
185
+ bucketArn,
186
+ objectArn,
187
+ prefixGlob,
188
+ tableActions: READ_TABLE_ACTIONS,
189
+ listActions: READ_S3_LIST_ACTIONS,
190
+ bucketActions: READ_S3_BUCKET_ACTIONS,
191
+ objectActions: READ_S3_OBJECT_ACTIONS,
192
+ });
193
+ }
194
+ grantWrite(grantee) {
195
+ return grantSplit(grantee, {
196
+ tableArn,
197
+ bucketArn,
198
+ objectArn,
199
+ prefixGlob,
200
+ tableActions: WRITE_TABLE_ACTIONS,
201
+ listActions: [],
202
+ bucketActions: WRITE_S3_BUCKET_ACTIONS,
203
+ objectActions: WRITE_S3_OBJECT_ACTIONS,
204
+ });
205
+ }
206
+ grantReadWrite(grantee) {
207
+ return grantSplit(grantee, {
208
+ tableArn,
209
+ bucketArn,
210
+ objectArn,
211
+ prefixGlob,
212
+ tableActions: [
213
+ ...READ_TABLE_ACTIONS,
214
+ ...WRITE_TABLE_ACTIONS,
215
+ ],
216
+ listActions: READ_S3_LIST_ACTIONS,
217
+ bucketActions: [
218
+ ...READ_S3_BUCKET_ACTIONS,
219
+ ...WRITE_S3_BUCKET_ACTIONS,
220
+ ],
221
+ objectActions: [
222
+ ...READ_S3_OBJECT_ACTIONS,
223
+ ...WRITE_S3_OBJECT_ACTIONS,
224
+ ],
225
+ });
226
+ }
227
+ }
228
+ return new Imported(scope, id);
229
+ }
230
+ /** Grant Glue read + S3 read on this table. */
231
+ grantRead(grantee) {
232
+ return grantSplit(grantee, {
233
+ tableArn: this.tableArn,
234
+ bucketArn: this.bucketArn,
235
+ objectArn: this.objectArn,
236
+ prefixGlob: this.s3PrefixGlob,
237
+ tableActions: READ_TABLE_ACTIONS,
238
+ listActions: READ_S3_LIST_ACTIONS,
239
+ bucketActions: READ_S3_BUCKET_ACTIONS,
240
+ objectActions: READ_S3_OBJECT_ACTIONS,
241
+ });
242
+ }
243
+ /** Grant Glue write + S3 write on this table. */
244
+ grantWrite(grantee) {
245
+ return grantSplit(grantee, {
246
+ tableArn: this.tableArn,
247
+ bucketArn: this.bucketArn,
248
+ objectArn: this.objectArn,
249
+ prefixGlob: this.s3PrefixGlob,
250
+ tableActions: WRITE_TABLE_ACTIONS,
251
+ listActions: [],
252
+ bucketActions: WRITE_S3_BUCKET_ACTIONS,
253
+ objectActions: WRITE_S3_OBJECT_ACTIONS,
254
+ });
255
+ }
256
+ /** Grant Glue + S3 read + write on this table. */
257
+ grantReadWrite(grantee) {
258
+ return grantSplit(grantee, {
259
+ tableArn: this.tableArn,
260
+ bucketArn: this.bucketArn,
261
+ objectArn: this.objectArn,
262
+ prefixGlob: this.s3PrefixGlob,
263
+ tableActions: [
264
+ ...READ_TABLE_ACTIONS,
265
+ ...WRITE_TABLE_ACTIONS,
266
+ ],
267
+ listActions: READ_S3_LIST_ACTIONS,
268
+ bucketActions: [
269
+ ...READ_S3_BUCKET_ACTIONS,
270
+ ...WRITE_S3_BUCKET_ACTIONS,
271
+ ],
272
+ objectActions: [
273
+ ...READ_S3_OBJECT_ACTIONS,
274
+ ...WRITE_S3_OBJECT_ACTIONS,
275
+ ],
276
+ });
277
+ }
278
+ }
279
+ exports.IcebergTable = IcebergTable;
280
+ /// /////////////////////////////////////////////////
281
+ /// /////////////////////////////////////////////////
282
+ // Validation
283
+ function validateProps(props) {
284
+ if (!props.tableName.match(/^[a-z0-9_]+$/)) {
285
+ throw new Error(`tableName '${props.tableName}' must contain only lowercase letters, digits, and underscores`);
286
+ }
287
+ if (props.columns.length === 0) {
288
+ throw new Error('IcebergTable requires at least one column');
289
+ }
290
+ const names = new Set();
291
+ for (const column of props.columns) {
292
+ if (names.has(column.name)) {
293
+ throw new Error(`duplicate column name: ${column.name}`);
294
+ }
295
+ names.add(column.name);
296
+ }
297
+ if (!props.location.startsWith('s3://')) {
298
+ throw new Error(`location must start with 's3://', got '${props.location}'`);
299
+ }
300
+ }
301
+ function normalizeLocation(location) {
302
+ return location.endsWith('/') ? location : `${location}/`;
303
+ }
304
+ function parseS3Uri(uri) {
305
+ /// `normalizeLocation` is always called first, so `uri` ends with `/`
306
+ /// and therefore contains at least one `/` after the scheme.
307
+ const rest = uri.substring('s3://'.length);
308
+ const slash = rest.indexOf('/');
309
+ return {
310
+ bucket: rest.substring(0, slash),
311
+ key: rest.substring(slash + 1),
312
+ };
313
+ }
314
+ function renderSchema(columns) {
315
+ /// First pass: assign top-level ids. Pinned ids win; the rest are
316
+ /// filled with the smallest unused positive integers. Nested-type
317
+ /// ids continue above the highest top-level id so they never
318
+ /// collide with column ids.
319
+ const topLevelIds = assignTopLevelIds(columns);
320
+ let nextId = Math.max(...topLevelIds, columns.length) + 1;
321
+ const ctx = {
322
+ nextId: () => {
323
+ const id = nextId;
324
+ nextId += 1;
325
+ return id;
326
+ },
327
+ };
328
+ const columnByName = new Map();
329
+ const fields = columns.map((column, index) => {
330
+ const id = topLevelIds[index];
331
+ const typeString = column.type._render(ctx);
332
+ columnByName.set(column.name, {
333
+ id,
334
+ type: column.type,
335
+ });
336
+ return {
337
+ id,
338
+ name: column.name,
339
+ type: typeString,
340
+ required: column.required ?? false,
341
+ doc: column.doc,
342
+ };
343
+ });
344
+ return {
345
+ fields,
346
+ columnByName,
347
+ };
348
+ }
349
+ /**
350
+ * Assign top-level field ids honoring user-pinned ids and filling
351
+ * unspecified ones with the smallest unused positive integer.
352
+ * Throws on duplicate or non-positive ids.
353
+ *
354
+ * @internal
355
+ */
356
+ function assignTopLevelIds(columns) {
357
+ const taken = new Set();
358
+ for (const column of columns) {
359
+ if (column.id === undefined) {
360
+ continue;
361
+ }
362
+ if (!Number.isInteger(column.id) || column.id < 1) {
363
+ throw new Error(`column '${column.name}' has invalid id ${column.id}; ids must be positive integers`);
364
+ }
365
+ if (taken.has(column.id)) {
366
+ throw new Error(`duplicate column id ${column.id} on column '${column.name}'`);
367
+ }
368
+ taken.add(column.id);
369
+ }
370
+ let cursor = 1;
371
+ return columns.map((column) => {
372
+ if (column.id !== undefined) {
373
+ return column.id;
374
+ }
375
+ while (taken.has(cursor)) {
376
+ cursor += 1;
377
+ }
378
+ taken.add(cursor);
379
+ const assigned = cursor;
380
+ cursor += 1;
381
+ return assigned;
382
+ });
383
+ }
384
+ function validatePartitionSpec(partitionSpec, columnByName) {
385
+ if (partitionSpec === undefined) {
386
+ return;
387
+ }
388
+ const partitionNames = new Set();
389
+ for (const field of partitionSpec) {
390
+ const source = columnByName.get(field.sourceColumn);
391
+ if (source === undefined) {
392
+ throw new Error(`partitionSpec references unknown column '${field.sourceColumn}'`);
393
+ }
394
+ field.transform.validateSourceType(field.sourceColumn, source.type);
395
+ const partitionName = field.name ?? defaultPartitionName(field);
396
+ if (partitionNames.has(partitionName)) {
397
+ throw new Error(`duplicate partition field name: ${partitionName}`);
398
+ }
399
+ partitionNames.add(partitionName);
400
+ }
401
+ }
402
+ function validateSortOrder(sortOrder, columnByName) {
403
+ if (sortOrder === undefined) {
404
+ return;
405
+ }
406
+ if (sortOrder.length === 0) {
407
+ throw new Error('sortOrder must contain at least one field when provided');
408
+ }
409
+ for (const field of sortOrder) {
410
+ const source = columnByName.get(field.sourceColumn);
411
+ if (source === undefined) {
412
+ throw new Error(`sortOrder references unknown column '${field.sourceColumn}'`);
413
+ }
414
+ const transform = field.transform ?? iceberg_partition_transform_1.IcebergPartitionTransform.IDENTITY;
415
+ transform.validateSourceType(field.sourceColumn, source.type);
416
+ }
417
+ }
418
+ function renderPartitionSpec(partitionSpec, columnByName) {
419
+ if (partitionSpec === undefined || partitionSpec.length === 0) {
420
+ return undefined;
421
+ }
422
+ const fields = partitionSpec.map((field, index) => ({
423
+ name: field.name ?? defaultPartitionName(field),
424
+ sourceId: columnByName.get(field.sourceColumn).id,
425
+ transform: field.transform.toTransformString(),
426
+ /// Per the Iceberg spec, partition field ids must be in the
427
+ /// range [1000, 9999]; the construct allocates them densely
428
+ /// from 1000 in declaration order.
429
+ fieldId: 1000 + index,
430
+ }));
431
+ return {
432
+ specId: 0,
433
+ fields,
434
+ };
435
+ }
436
+ function renderSortOrder(sortOrder, columnByName) {
437
+ if (sortOrder === undefined || sortOrder.length === 0) {
438
+ return undefined;
439
+ }
440
+ const fields = sortOrder.map((field) => {
441
+ const transform = field.transform ?? iceberg_partition_transform_1.IcebergPartitionTransform.IDENTITY;
442
+ return {
443
+ sourceId: columnByName.get(field.sourceColumn).id,
444
+ transform: transform.toTransformString(),
445
+ direction: field.direction ?? IcebergSortDirection.ASC,
446
+ nullOrder: field.nullOrder ?? IcebergNullOrder.NULLS_LAST,
447
+ };
448
+ });
449
+ return {
450
+ orderId: 1,
451
+ fields,
452
+ };
453
+ }
454
+ function defaultPartitionName(field) {
455
+ const transformString = field.transform.toTransformString();
456
+ if (transformString === 'identity') {
457
+ return field.sourceColumn;
458
+ }
459
+ /// `bucket[16]` -> `sourceColumn_bucket`
460
+ const baseTransform = transformString.replace(/\[.*\]$/, '');
461
+ return `${field.sourceColumn}_${baseTransform}`;
462
+ }
463
+ function resolveIdentifierFieldIds(identifierFieldNames, columnByName) {
464
+ if (identifierFieldNames === undefined || identifierFieldNames.length === 0) {
465
+ return undefined;
466
+ }
467
+ const seen = new Set();
468
+ return identifierFieldNames.map((name) => {
469
+ if (seen.has(name)) {
470
+ throw new Error(`duplicate identifier field: ${name}`);
471
+ }
472
+ seen.add(name);
473
+ const column = columnByName.get(name);
474
+ if (column === undefined) {
475
+ throw new Error(`identifierFieldNames references unknown column '${name}'`);
476
+ }
477
+ return column.id;
478
+ });
479
+ }
480
+ function mergeProperties(dataFormat, formatVersion, user, comment) {
481
+ const merged = {
482
+ [iceberg_table_properties_1.ICEBERG_PROPERTY_KEYS.FORMAT_VERSION]: formatVersion,
483
+ [iceberg_table_properties_1.ICEBERG_PROPERTY_KEYS.WRITE_FORMAT_DEFAULT]: dataFormat,
484
+ ...(user ?? {}),
485
+ };
486
+ if (comment !== undefined) {
487
+ merged.comment = comment;
488
+ }
489
+ return merged;
490
+ }
491
+ /**
492
+ * Issue the four policy statements that scope an Iceberg-table grant
493
+ * correctly: Glue actions on the table ARN, S3 list-bucket actions
494
+ * on the bucket ARN with an `s3:prefix` condition so only the
495
+ * table's own prefix can be listed, S3 bucket-level actions that DO
496
+ * NOT support the `s3:prefix` condition (e.g. `GetBucketLocation`,
497
+ * `ListBucketMultipartUploads`) on the bucket ARN with no condition
498
+ * — including them in the conditioned statement would silently deny
499
+ * them at runtime — and S3 object-level actions on the
500
+ * `bucket/prefix*` ARN. Returns the table-actions grant (any of the
501
+ * four is sufficient for the `Grant` API contract; the rest attach
502
+ * as side effects).
503
+ *
504
+ * @internal
505
+ */
506
+ function grantSplit(grantee, args) {
507
+ const tableGrant = aws_iam_1.Grant.addToPrincipal({
508
+ grantee,
509
+ actions: args.tableActions,
510
+ resourceArns: [
511
+ args.tableArn,
512
+ ],
513
+ });
514
+ if (args.listActions.length > 0) {
515
+ aws_iam_1.Grant.addToPrincipal({
516
+ grantee,
517
+ actions: args.listActions,
518
+ resourceArns: [
519
+ args.bucketArn,
520
+ ],
521
+ conditions: {
522
+ StringLike: {
523
+ 's3:prefix': [
524
+ args.prefixGlob,
525
+ args.prefixGlob.replace(/\*$/, ''),
526
+ ],
527
+ },
528
+ },
529
+ });
530
+ }
531
+ if (args.bucketActions.length > 0) {
532
+ aws_iam_1.Grant.addToPrincipal({
533
+ grantee,
534
+ actions: args.bucketActions,
535
+ resourceArns: [
536
+ args.bucketArn,
537
+ ],
538
+ });
539
+ }
540
+ aws_iam_1.Grant.addToPrincipal({
541
+ grantee,
542
+ actions: args.objectActions,
543
+ resourceArns: [
544
+ args.objectArn,
545
+ ],
546
+ });
547
+ return tableGrant;
548
+ }
549
+ //# sourceMappingURL=data:application/json;base64,{"version":3,"file":"iceberg-table.js","sourceRoot":"","sources":["../../../lib/iceberg/iceberg-table.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n    Resource,\n    Stack,\n    RemovalPolicy,\n} from 'aws-cdk-lib';\nimport {\n    CfnTable,\n} from 'aws-cdk-lib/aws-glue';\nimport {\n    Grant,\n    IGrantable,\n} from 'aws-cdk-lib/aws-iam';\nimport {\n    Construct,\n} from 'constructs';\nimport {\n    IDatabase,\n} from '@aws-cdk/aws-glue-alpha';\nimport {\n    IcebergRenderContext,\n    IcebergType,\n} from './iceberg-type';\nimport {\n    IcebergPartitionTransform,\n} from './iceberg-partition-transform';\nimport {\n    ICEBERG_PROPERTY_KEYS,\n    IcebergDataFormat,\n    IcebergFormatVersion,\n    validateIcebergProperties,\n} from './iceberg-table-properties';\n\n/// /////////////////////////////////////////////////\n/// /////////////////////////////////////////////////\n// Sort order enums\n\n/** Sort direction for an Iceberg sort field. */\nexport enum IcebergSortDirection {\n    /** Ascending — smaller values first. */\n    ASC = 'asc',\n\n    /** Descending — larger values first. */\n    DESC = 'desc',\n}\n\n/** Null ordering for an Iceberg sort field. */\nexport enum IcebergNullOrder {\n    /** Nulls precede all non-null values. */\n    NULLS_FIRST = 'nulls-first',\n\n    /** Nulls follow all non-null values. */\n    NULLS_LAST = 'nulls-last',\n}\n\n/// /////////////////////////////////////////////////\n/// /////////////////////////////////////////////////\n// Public construct types\n\n/** One top-level column in an Iceberg table. */\nexport interface IcebergColumn {\n    /** Column name (unique within the table). */\n    readonly name: string;\n\n    /** Column type. */\n    readonly type: IcebergType;\n\n    /**\n     * Whether the column is non-nullable. Defaults to `false` to\n     * match the Iceberg spec default of optional fields.\n     */\n    readonly required?: boolean;\n\n    /** Optional documentation string. */\n    readonly doc?: string;\n\n    /**\n     * Pin this column to a specific Iceberg field id. Highly\n     * recommended for production tables: it lets you safely add,\n     * remove, and reorder columns across `cdk deploy`s without\n     * triggering Iceberg's silent-corruption-on-id-reuse trap. When\n     * omitted the construct assigns ids by position (1..N for the\n     * top-level columns), which is fine for fresh tables but unsafe\n     * once the table has data and you start dropping columns.\n     */\n    readonly id?: number;\n}\n\n/** One partition spec field. */\nexport interface IcebergPartitionField {\n    /** Name of the top-level table column this partition derives from. */\n    readonly sourceColumn: string;\n\n    /** Transform to apply to the source column. */\n    readonly transform: IcebergPartitionTransform;\n\n    /**\n     * Display name for the partition field. Defaults to\n     * `<sourceColumn>` for identity transforms and\n     * `<sourceColumn>_<transform>` otherwise.\n     */\n    readonly name?: string;\n}\n\n/** One write-order (sort) field. */\nexport interface IcebergSortField {\n    /** Name of the top-level table column to sort on. */\n    readonly sourceColumn: string;\n\n    /** Transform to apply to the source column. Defaults to `identity`. */\n    readonly transform?: IcebergPartitionTransform;\n\n    /** Sort direction. Defaults to `ASC`. */\n    readonly direction?: IcebergSortDirection;\n\n    /** Null ordering. Defaults to `NULLS_LAST`. */\n    readonly nullOrder?: IcebergNullOrder;\n}\n\n/** Construction properties for an `IcebergTable`. */\nexport interface IcebergTableProps {\n    /** Glue database that will hold the table. */\n    readonly database: IDatabase;\n\n    /** Table name (lower-case, no spaces — Glue and Athena will fold it). */\n    readonly tableName: string;\n\n    /** Top-level columns. Must contain at least one column. */\n    readonly columns: IcebergColumn[];\n\n    /** S3 URI where Iceberg metadata + data live. Must start with `s3://`. */\n    readonly location: string;\n\n    /** Optional partition spec. Order is preserved in the partition layout. */\n    readonly partitionSpec?: IcebergPartitionField[];\n\n    /** Optional default write order. Realized as `IcebergTableInput.writeOrder`. */\n    readonly sortOrder?: IcebergSortField[];\n\n    /**\n     * Names of columns that together identify a row. Maps to\n     * `IcebergSchema.identifierFieldIds`. Per the Iceberg spec these\n     * must be primitive, non-nullable, non-floating-point fields.\n     */\n    readonly identifierFieldNames?: string[];\n\n    /** Data-file storage format. Defaults to `PARQUET`. */\n    readonly dataFormat?: IcebergDataFormat;\n\n    /** Iceberg format version. Defaults to `V2`. */\n    readonly formatVersion?: IcebergFormatVersion;\n\n    /**\n     * Extra `properties` to publish on the table. Auto-added keys\n     * (`format-version`, `write.format.default`) are merged in and\n     * must agree with `formatVersion` / `dataFormat` if user-supplied.\n     */\n    readonly tableProperties?: { [key: string]: string };\n\n    /**\n     * Optional table comment. Glue's `OpenTableFormatInput` shape is\n     * mutually exclusive with `TableInput.Description`, so the\n     * construct cannot surface a description through the regular\n     * Glue field. The comment is published in the Iceberg\n     * `properties` map under the `comment` key, where Athena's\n     * `SHOW TBLPROPERTIES` and Iceberg-aware readers can find it.\n     */\n    readonly comment?: string;\n\n    /**\n     * Removal policy for the underlying Glue table. Defaults to `RETAIN`\n     * to match how CloudFormation treats Glue tables by default and to\n     * avoid accidentally dropping production metadata.\n     */\n    readonly removalPolicy?: RemovalPolicy;\n}\n\n/** Public interface implemented by `IcebergTable` and by import shims. */\nexport interface IIcebergTable {\n    /** Glue ARN of the table. */\n    readonly tableArn: string;\n\n    /** Table name. */\n    readonly tableName: string;\n\n    /** Glue database holding the table. */\n    readonly database: IDatabase;\n\n    /** S3 URI where the table is materialized. */\n    readonly location: string;\n\n    /** Grant Glue + S3 read on this table. */\n    grantRead(grantee: IGrantable): Grant;\n\n    /** Grant Glue + S3 write on this table. */\n    grantWrite(grantee: IGrantable): Grant;\n\n    /** Grant Glue + S3 read + write on this table. */\n    grantReadWrite(grantee: IGrantable): Grant;\n}\n\n/// /////////////////////////////////////////////////\n/// /////////////////////////////////////////////////\n// Grant action sets\n\nconst READ_TABLE_ACTIONS = [\n    'glue:BatchGetPartition',\n    'glue:GetPartition',\n    'glue:GetPartitions',\n    'glue:GetTable',\n    'glue:GetTables',\n    'glue:GetTableVersion',\n    'glue:GetTableVersions',\n];\n\nconst WRITE_TABLE_ACTIONS = [\n    'glue:BatchCreatePartition',\n    'glue:BatchDeletePartition',\n    'glue:CreatePartition',\n    'glue:DeletePartition',\n    'glue:UpdatePartition',\n    'glue:UpdateTable',\n];\n\n/// S3 actions that operate at the bucket level AND support the\n/// `s3:prefix` request condition key (per the S3 docs). Granted on\n/// the bucket ARN with a `StringLike s3:prefix = [<prefix>*, <prefix>]`\n/// condition so the grantee can only list the table's own prefix.\nconst READ_S3_LIST_ACTIONS = [\n    's3:ListBucket',\n];\n\n/// S3 actions that operate at the bucket level but DO NOT support\n/// `s3:prefix`. Granted on the bucket ARN with no condition — adding\n/// one would silently deny these actions at runtime even though they\n/// appear in the policy document.\nconst READ_S3_BUCKET_ACTIONS = [\n    's3:GetBucketLocation',\n];\n\nconst WRITE_S3_BUCKET_ACTIONS = [\n    's3:ListBucketMultipartUploads',\n];\n\n/// S3 actions that operate at the object level. Must be granted on\n/// the `bucket/prefix*` ARN.\nconst READ_S3_OBJECT_ACTIONS = [\n    's3:GetObject',\n];\n\nconst WRITE_S3_OBJECT_ACTIONS = [\n    's3:PutObject',\n    's3:DeleteObject',\n    's3:AbortMultipartUpload',\n    's3:ListMultipartUploadParts',\n];\n\n/// /////////////////////////////////////////////////\n/// /////////////////////////////////////////////////\n// IcebergTable\n\n/**\n * A Glue table created in the Apache Iceberg open table format.\n *\n * The construct emits the\n * `OpenTableFormatInput.IcebergInput.IcebergTableInput` shape that\n * survives CloudFormation `Update` (the alternative — placing columns\n * under `tableInput.storageDescriptor.columns` — silently strips\n * `table_type=ICEBERG` from Glue parameters on the first update and\n * leaves the table un-queryable in Athena).\n */\nexport class IcebergTable extends Resource implements IIcebergTable {\n    /** Glue ARN of the table. */\n    public readonly tableArn: string;\n\n    /** Table name as it appears in Glue / Athena. */\n    public readonly tableName: string;\n\n    /** Glue database holding the table. */\n    public readonly database: IDatabase;\n\n    /** S3 URI where the Iceberg metadata + data live. */\n    public readonly location: string;\n\n    /** Resolved data format (after defaulting). */\n    public readonly dataFormat: IcebergDataFormat;\n\n    /** Resolved format version (after defaulting). */\n    public readonly formatVersion: IcebergFormatVersion;\n\n    /** The underlying L1 — exposed for escape-hatch use. */\n    public readonly resource: CfnTable;\n\n    private readonly bucketArn: string;\n    private readonly objectArn: string;\n    private readonly s3PrefixGlob: string;\n\n    constructor(scope: Construct, id: string, props: IcebergTableProps) {\n        super(scope, id, {\n            physicalName: props.tableName,\n        });\n\n        validateProps(props);\n\n        this.database = props.database;\n        this.tableName = props.tableName;\n        this.location = normalizeLocation(props.location);\n        this.dataFormat = props.dataFormat ?? IcebergDataFormat.PARQUET;\n        this.formatVersion = props.formatVersion ?? IcebergFormatVersion.V2;\n\n        const parsed = parseS3Uri(this.location);\n        this.bucketArn = `arn:${Stack.of(this).partition}:s3:::${parsed.bucket}`;\n        this.objectArn = `${this.bucketArn}/${parsed.key}*`;\n        this.s3PrefixGlob = `${parsed.key}*`;\n\n        const mergedProperties = mergeProperties(\n            this.dataFormat,\n            this.formatVersion,\n            props.tableProperties,\n            props.comment,\n        );\n        validateIcebergProperties(this.dataFormat, this.formatVersion, mergedProperties);\n\n        const rendered = renderSchema(props.columns);\n        validatePartitionSpec(props.partitionSpec, rendered.columnByName);\n        validateSortOrder(props.sortOrder, rendered.columnByName);\n        const identifierFieldIds = resolveIdentifierFieldIds(props.identifierFieldNames, rendered.columnByName);\n\n        this.resource = new CfnTable(this, 'Resource', {\n            catalogId: Stack.of(this).account,\n            databaseName: props.database.databaseName,\n            name: this.tableName,\n            openTableFormatInput: {\n                icebergInput: {\n                    metadataOperation: 'CREATE',\n                    version: this.formatVersion,\n                    icebergTableInput: {\n                        location: this.location,\n                        schema: {\n                            type: 'struct',\n                            schemaId: 0,\n                            fields: rendered.fields,\n                            identifierFieldIds: identifierFieldIds,\n                        },\n                        partitionSpec: renderPartitionSpec(props.partitionSpec, rendered.columnByName),\n                        writeOrder: renderSortOrder(props.sortOrder, rendered.columnByName),\n                        properties: mergedProperties,\n                    },\n                },\n            },\n        });\n\n        const removalPolicy = props.removalPolicy ?? RemovalPolicy.RETAIN;\n        this.resource.applyRemovalPolicy(removalPolicy);\n\n        this.tableArn = Stack.of(this).formatArn({\n            service: 'glue',\n            resource: 'table',\n            resourceName: `${props.database.databaseName}/${this.tableName}`,\n        });\n\n        this.node.defaultChild = this.resource;\n    }\n\n    /**\n     * Import an existing Iceberg table by its name + database.\n     *\n     * Imported tables can be referenced from grants but cannot be\n     * mutated; their schema and properties are unknown to CDK.\n     */\n    public static fromIcebergTableAttributes(\n        scope: Construct,\n        id: string,\n        attrs: IcebergTableAttributes,\n    ): IIcebergTable {\n        const stack = Stack.of(scope);\n        const location = normalizeLocation(attrs.location);\n        const parsed = parseS3Uri(location);\n        const bucketArn = `arn:${stack.partition}:s3:::${parsed.bucket}`;\n        const objectArn = `${bucketArn}/${parsed.key}*`;\n        const prefixGlob = `${parsed.key}*`;\n        const tableArn = stack.formatArn({\n            service: 'glue',\n            resource: 'table',\n            resourceName: `${attrs.database.databaseName}/${attrs.tableName}`,\n        });\n\n        class Imported extends Resource implements IIcebergTable {\n            public readonly tableArn = tableArn;\n            public readonly tableName = attrs.tableName;\n            public readonly database = attrs.database;\n            public readonly location = location;\n\n            public grantRead(grantee: IGrantable): Grant {\n                return grantSplit(grantee, {\n                    tableArn,\n                    bucketArn,\n                    objectArn,\n                    prefixGlob,\n                    tableActions: READ_TABLE_ACTIONS,\n                    listActions: READ_S3_LIST_ACTIONS,\n                    bucketActions: READ_S3_BUCKET_ACTIONS,\n                    objectActions: READ_S3_OBJECT_ACTIONS,\n                });\n            }\n\n            public grantWrite(grantee: IGrantable): Grant {\n                return grantSplit(grantee, {\n                    tableArn,\n                    bucketArn,\n                    objectArn,\n                    prefixGlob,\n                    tableActions: WRITE_TABLE_ACTIONS,\n                    listActions: [],\n                    bucketActions: WRITE_S3_BUCKET_ACTIONS,\n                    objectActions: WRITE_S3_OBJECT_ACTIONS,\n                });\n            }\n\n            public grantReadWrite(grantee: IGrantable): Grant {\n                return grantSplit(grantee, {\n                    tableArn,\n                    bucketArn,\n                    objectArn,\n                    prefixGlob,\n                    tableActions: [\n                        ...READ_TABLE_ACTIONS,\n                        ...WRITE_TABLE_ACTIONS,\n                    ],\n                    listActions: READ_S3_LIST_ACTIONS,\n                    bucketActions: [\n                        ...READ_S3_BUCKET_ACTIONS,\n                        ...WRITE_S3_BUCKET_ACTIONS,\n                    ],\n                    objectActions: [\n                        ...READ_S3_OBJECT_ACTIONS,\n                        ...WRITE_S3_OBJECT_ACTIONS,\n                    ],\n                });\n            }\n        }\n\n        return new Imported(scope, id);\n    }\n\n    /** Grant Glue read + S3 read on this table. */\n    public grantRead(grantee: IGrantable): Grant {\n        return grantSplit(grantee, {\n            tableArn: this.tableArn,\n            bucketArn: this.bucketArn,\n            objectArn: this.objectArn,\n            prefixGlob: this.s3PrefixGlob,\n            tableActions: READ_TABLE_ACTIONS,\n            listActions: READ_S3_LIST_ACTIONS,\n            bucketActions: READ_S3_BUCKET_ACTIONS,\n            objectActions: READ_S3_OBJECT_ACTIONS,\n        });\n    }\n\n    /** Grant Glue write + S3 write on this table. */\n    public grantWrite(grantee: IGrantable): Grant {\n        return grantSplit(grantee, {\n            tableArn: this.tableArn,\n            bucketArn: this.bucketArn,\n            objectArn: this.objectArn,\n            prefixGlob: this.s3PrefixGlob,\n            tableActions: WRITE_TABLE_ACTIONS,\n            listActions: [],\n            bucketActions: WRITE_S3_BUCKET_ACTIONS,\n            objectActions: WRITE_S3_OBJECT_ACTIONS,\n        });\n    }\n\n    /** Grant Glue + S3 read + write on this table. */\n    public grantReadWrite(grantee: IGrantable): Grant {\n        return grantSplit(grantee, {\n            tableArn: this.tableArn,\n            bucketArn: this.bucketArn,\n            objectArn: this.objectArn,\n            prefixGlob: this.s3PrefixGlob,\n            tableActions: [\n                ...READ_TABLE_ACTIONS,\n                ...WRITE_TABLE_ACTIONS,\n            ],\n            listActions: READ_S3_LIST_ACTIONS,\n            bucketActions: [\n                ...READ_S3_BUCKET_ACTIONS,\n                ...WRITE_S3_BUCKET_ACTIONS,\n            ],\n            objectActions: [\n                ...READ_S3_OBJECT_ACTIONS,\n                ...WRITE_S3_OBJECT_ACTIONS,\n            ],\n        });\n    }\n}\n\n/** Attributes needed to import an existing Iceberg table. */\nexport interface IcebergTableAttributes {\n    /** Glue database holding the table. */\n    readonly database: IDatabase;\n\n    /** Existing table's name. */\n    readonly tableName: string;\n\n    /** S3 URI where the table's data + metadata live. */\n    readonly location: string;\n}\n\n/// /////////////////////////////////////////////////\n/// /////////////////////////////////////////////////\n// Validation\n\nfunction validateProps(props: IcebergTableProps): void {\n    if (!props.tableName.match(/^[a-z0-9_]+$/)) {\n        throw new Error(\n            `tableName '${props.tableName}' must contain only lowercase letters, digits, and underscores`,\n        );\n    }\n    if (props.columns.length === 0) {\n        throw new Error('IcebergTable requires at least one column');\n    }\n    const names = new Set<string>();\n    for (const column of props.columns) {\n        if (names.has(column.name)) {\n            throw new Error(`duplicate column name: ${column.name}`);\n        }\n        names.add(column.name);\n    }\n    if (!props.location.startsWith('s3://')) {\n        throw new Error(`location must start with 's3://', got '${props.location}'`);\n    }\n}\n\nfunction normalizeLocation(location: string): string {\n    return location.endsWith('/') ? location : `${location}/`;\n}\n\nfunction parseS3Uri(uri: string): { bucket: string; key: string } {\n    /// `normalizeLocation` is always called first, so `uri` ends with `/`\n    /// and therefore contains at least one `/` after the scheme.\n    const rest = uri.substring('s3://'.length);\n    const slash = rest.indexOf('/');\n    return {\n        bucket: rest.substring(0, slash),\n        key: rest.substring(slash + 1),\n    };\n}\n\n/// /////////////////////////////////////////////////\n/// /////////////////////////////////////////////////\n// Schema / partition / sort rendering\n\ninterface RenderedColumn {\n    readonly id: number;\n    readonly type: IcebergType;\n}\n\ninterface RenderedSchema {\n    readonly fields: CfnTable.IcebergStructFieldProperty[];\n    readonly columnByName: Map<string, RenderedColumn>;\n}\n\nfunction renderSchema(columns: IcebergColumn[]): RenderedSchema {\n    /// First pass: assign top-level ids. Pinned ids win; the rest are\n    /// filled with the smallest unused positive integers. Nested-type\n    /// ids continue above the highest top-level id so they never\n    /// collide with column ids.\n    const topLevelIds = assignTopLevelIds(columns);\n    let nextId = Math.max(...topLevelIds, columns.length) + 1;\n    const ctx: IcebergRenderContext = {\n        nextId: () => {\n            const id = nextId;\n            nextId += 1;\n            return id;\n        },\n    };\n    const columnByName = new Map<string, RenderedColumn>();\n    const fields: CfnTable.IcebergStructFieldProperty[] = columns.map((column, index) => {\n        const id = topLevelIds[index];\n        const typeString = column.type._render(ctx);\n        columnByName.set(column.name, {\n            id,\n            type: column.type,\n        });\n        return {\n            id,\n            name: column.name,\n            type: typeString,\n            required: column.required ?? false,\n            doc: column.doc,\n        };\n    });\n    return {\n        fields,\n        columnByName,\n    };\n}\n\n/**\n * Assign top-level field ids honoring user-pinned ids and filling\n * unspecified ones with the smallest unused positive integer.\n * Throws on duplicate or non-positive ids.\n *\n * @internal\n */\nfunction assignTopLevelIds(columns: IcebergColumn[]): number[] {\n    const taken = new Set<number>();\n    for (const column of columns) {\n        if (column.id === undefined) {\n            continue;\n        }\n        if (!Number.isInteger(column.id) || column.id < 1) {\n            throw new Error(\n                `column '${column.name}' has invalid id ${column.id}; ids must be positive integers`,\n            );\n        }\n        if (taken.has(column.id)) {\n            throw new Error(`duplicate column id ${column.id} on column '${column.name}'`);\n        }\n        taken.add(column.id);\n    }\n    let cursor = 1;\n    return columns.map((column) => {\n        if (column.id !== undefined) {\n            return column.id;\n        }\n        while (taken.has(cursor)) {\n            cursor += 1;\n        }\n        taken.add(cursor);\n        const assigned = cursor;\n        cursor += 1;\n        return assigned;\n    });\n}\n\nfunction validatePartitionSpec(\n    partitionSpec: IcebergPartitionField[] | undefined,\n    columnByName: Map<string, RenderedColumn>,\n): void {\n    if (partitionSpec === undefined) {\n        return;\n    }\n    const partitionNames = new Set<string>();\n    for (const field of partitionSpec) {\n        const source = columnByName.get(field.sourceColumn);\n        if (source === undefined) {\n            throw new Error(\n                `partitionSpec references unknown column '${field.sourceColumn}'`,\n            );\n        }\n        field.transform.validateSourceType(field.sourceColumn, source.type);\n        const partitionName = field.name ?? defaultPartitionName(field);\n        if (partitionNames.has(partitionName)) {\n            throw new Error(`duplicate partition field name: ${partitionName}`);\n        }\n        partitionNames.add(partitionName);\n    }\n}\n\nfunction validateSortOrder(\n    sortOrder: IcebergSortField[] | undefined,\n    columnByName: Map<string, RenderedColumn>,\n): void {\n    if (sortOrder === undefined) {\n        return;\n    }\n    if (sortOrder.length === 0) {\n        throw new Error('sortOrder must contain at least one field when provided');\n    }\n    for (const field of sortOrder) {\n        const source = columnByName.get(field.sourceColumn);\n        if (source === undefined) {\n            throw new Error(`sortOrder references unknown column '${field.sourceColumn}'`);\n        }\n        const transform = field.transform ?? IcebergPartitionTransform.IDENTITY;\n        transform.validateSourceType(field.sourceColumn, source.type);\n    }\n}\n\nfunction renderPartitionSpec(\n    partitionSpec: IcebergPartitionField[] | undefined,\n    columnByName: Map<string, RenderedColumn>,\n): CfnTable.IcebergPartitionSpecProperty | undefined {\n    if (partitionSpec === undefined || partitionSpec.length === 0) {\n        return undefined;\n    }\n    const fields: CfnTable.IcebergPartitionFieldProperty[] = partitionSpec.map((field, index) => ({\n        name: field.name ?? defaultPartitionName(field),\n        sourceId: columnByName.get(field.sourceColumn)!.id,\n        transform: field.transform.toTransformString(),\n        /// Per the Iceberg spec, partition field ids must be in the\n        /// range [1000, 9999]; the construct allocates them densely\n        /// from 1000 in declaration order.\n        fieldId: 1000 + index,\n    }));\n    return {\n        specId: 0,\n        fields,\n    };\n}\n\nfunction renderSortOrder(\n    sortOrder: IcebergSortField[] | undefined,\n    columnByName: Map<string, RenderedColumn>,\n): CfnTable.IcebergSortOrderProperty | undefined {\n    if (sortOrder === undefined || sortOrder.length === 0) {\n        return undefined;\n    }\n    const fields: CfnTable.IcebergSortFieldProperty[] = sortOrder.map((field) => {\n        const transform = field.transform ?? IcebergPartitionTransform.IDENTITY;\n        return {\n            sourceId: columnByName.get(field.sourceColumn)!.id,\n            transform: transform.toTransformString(),\n            direction: field.direction ?? IcebergSortDirection.ASC,\n            nullOrder: field.nullOrder ?? IcebergNullOrder.NULLS_LAST,\n        };\n    });\n    return {\n        orderId: 1,\n        fields,\n    };\n}\n\nfunction defaultPartitionName(field: IcebergPartitionField): string {\n    const transformString = field.transform.toTransformString();\n    if (transformString === 'identity') {\n        return field.sourceColumn;\n    }\n    /// `bucket[16]` -> `sourceColumn_bucket`\n    const baseTransform = transformString.replace(/\\[.*\\]$/, '');\n    return `${field.sourceColumn}_${baseTransform}`;\n}\n\nfunction resolveIdentifierFieldIds(\n    identifierFieldNames: string[] | undefined,\n    columnByName: Map<string, RenderedColumn>,\n): number[] | undefined {\n    if (identifierFieldNames === undefined || identifierFieldNames.length === 0) {\n        return undefined;\n    }\n    const seen = new Set<string>();\n    return identifierFieldNames.map((name) => {\n        if (seen.has(name)) {\n            throw new Error(`duplicate identifier field: ${name}`);\n        }\n        seen.add(name);\n        const column = columnByName.get(name);\n        if (column === undefined) {\n            throw new Error(`identifierFieldNames references unknown column '${name}'`);\n        }\n        return column.id;\n    });\n}\n\nfunction mergeProperties(\n    dataFormat: IcebergDataFormat,\n    formatVersion: IcebergFormatVersion,\n    user: { [key: string]: string } | undefined,\n    comment: string | undefined,\n): { [key: string]: string } {\n    const merged: { [key: string]: string } = {\n        [ICEBERG_PROPERTY_KEYS.FORMAT_VERSION]: formatVersion,\n        [ICEBERG_PROPERTY_KEYS.WRITE_FORMAT_DEFAULT]: dataFormat,\n        ...(user ?? {}),\n    };\n    if (comment !== undefined) {\n        merged.comment = comment;\n    }\n    return merged;\n}\n\n/**\n * Issue the four policy statements that scope an Iceberg-table grant\n * correctly: Glue actions on the table ARN, S3 list-bucket actions\n * on the bucket ARN with an `s3:prefix` condition so only the\n * table's own prefix can be listed, S3 bucket-level actions that DO\n * NOT support the `s3:prefix` condition (e.g. `GetBucketLocation`,\n * `ListBucketMultipartUploads`) on the bucket ARN with no condition\n * — including them in the conditioned statement would silently deny\n * them at runtime — and S3 object-level actions on the\n * `bucket/prefix*` ARN. Returns the table-actions grant (any of the\n * four is sufficient for the `Grant` API contract; the rest attach\n * as side effects).\n *\n * @internal\n */\nfunction grantSplit(\n    grantee: IGrantable,\n    args: {\n        tableArn: string;\n        bucketArn: string;\n        objectArn: string;\n        prefixGlob: string;\n        tableActions: string[];\n        listActions: string[];\n        bucketActions: string[];\n        objectActions: string[];\n    },\n): Grant {\n    const tableGrant = Grant.addToPrincipal({\n        grantee,\n        actions: args.tableActions,\n        resourceArns: [\n            args.tableArn,\n        ],\n    });\n    if (args.listActions.length > 0) {\n        Grant.addToPrincipal({\n            grantee,\n            actions: args.listActions,\n            resourceArns: [\n                args.bucketArn,\n            ],\n            conditions: {\n                StringLike: {\n                    's3:prefix': [\n                        args.prefixGlob,\n                        args.prefixGlob.replace(/\\*$/, ''),\n                    ],\n                },\n            },\n        });\n    }\n    if (args.bucketActions.length > 0) {\n        Grant.addToPrincipal({\n            grantee,\n            actions: args.bucketActions,\n            resourceArns: [\n                args.bucketArn,\n            ],\n        });\n    }\n    Grant.addToPrincipal({\n        grantee,\n        actions: args.objectActions,\n        resourceArns: [\n            args.objectArn,\n        ],\n    });\n    return tableGrant;\n}\n"]}