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,182 @@
1
+ /**
2
+ * Iceberg primitive and nested type representation.
3
+ *
4
+ * Iceberg field types are serialized to a string when a primitive
5
+ * (`int`, `long`, `decimal(10,2)`, ...) and to a JSON object embedded
6
+ * as a string when nested (`list`, `map`, `struct`). The Glue CFN
7
+ * surface accepts either form in `IcebergStructField.type`, so the L2
8
+ * always renders to `string`.
9
+ *
10
+ * Nested types carry their own field IDs (`element-id`, `key-id`,
11
+ * `value-id`, and per-field `id` inside structs). Those IDs must be
12
+ * globally unique inside one Iceberg table — so when `IcebergTable`
13
+ * walks its columns it threads a single monotonically-increasing
14
+ * counter through every type to assign them.
15
+ *
16
+ * `IcebergType` is intentionally jsii-friendly: one concrete class,
17
+ * discriminated by a public `kind` enum, all fields are public
18
+ * readonly so non-TypeScript bindings see the same shape, and the
19
+ * public constructor runs the same validation as the static factories
20
+ * (callers cannot reach the constructor without going through a kind
21
+ * + matching data combination).
22
+ */
23
+ /** @internal Render-time state — currently just a monotonic id generator. */
24
+ export interface IcebergRenderContext {
25
+ /** Returns the next unused field/element/key/value id. */
26
+ nextId(): number;
27
+ }
28
+ /** Discriminator for `IcebergType`. */
29
+ export declare enum IcebergTypeKind {
30
+ BOOLEAN = "boolean",
31
+ INT = "int",
32
+ LONG = "long",
33
+ FLOAT = "float",
34
+ DOUBLE = "double",
35
+ DATE = "date",
36
+ TIME = "time",
37
+ TIMESTAMP = "timestamp",
38
+ TIMESTAMPTZ = "timestamptz",
39
+ STRING = "string",
40
+ UUID = "uuid",
41
+ BINARY = "binary",
42
+ DECIMAL = "decimal",
43
+ FIXED = "fixed",
44
+ LIST = "list",
45
+ MAP = "map",
46
+ STRUCT = "struct"
47
+ }
48
+ /** Definition of a single struct field. */
49
+ export interface IcebergStructFieldDefinition {
50
+ /** Field name (unique within the struct). */
51
+ readonly name: string;
52
+ /** Field type. */
53
+ readonly type: IcebergType;
54
+ /** Whether the field is non-nullable. Defaults to `false`. */
55
+ readonly required?: boolean;
56
+ /** Optional documentation string. */
57
+ readonly doc?: string;
58
+ }
59
+ /**
60
+ * Construction options for an `IcebergType`.
61
+ *
62
+ * Most callers should use the static factories (`IcebergType.BOOLEAN`,
63
+ * `IcebergType.list(...)`, etc.) rather than instantiate directly.
64
+ * The constructor exists for jsii reflection; it runs the same
65
+ * validation as the factories.
66
+ */
67
+ export interface IcebergTypeOptions {
68
+ /** Discriminator. */
69
+ readonly kind: IcebergTypeKind;
70
+ /** Decimal precision (1..38). Required when `kind === DECIMAL`. */
71
+ readonly decimalPrecision?: number;
72
+ /** Decimal scale (0..precision). Required when `kind === DECIMAL`. */
73
+ readonly decimalScale?: number;
74
+ /** Fixed-byte length (positive). Required when `kind === FIXED`. */
75
+ readonly fixedLength?: number;
76
+ /** Element type. Required when `kind === LIST`. */
77
+ readonly listElement?: IcebergType;
78
+ /** Whether list elements are non-nullable. Defaults to `true`. */
79
+ readonly listElementRequired?: boolean;
80
+ /** Map key type. Required when `kind === MAP`. */
81
+ readonly mapKey?: IcebergType;
82
+ /** Map value type. Required when `kind === MAP`. */
83
+ readonly mapValue?: IcebergType;
84
+ /** Whether map values are non-nullable. Defaults to `true`. */
85
+ readonly mapValueRequired?: boolean;
86
+ /** Struct fields (non-empty, unique names). Required when `kind === STRUCT`. */
87
+ readonly structFields?: IcebergStructFieldDefinition[];
88
+ }
89
+ /**
90
+ * Iceberg type. Use the static factories on this class to construct
91
+ * primitives, decimals, fixed, lists, maps, and structs.
92
+ */
93
+ export declare class IcebergType {
94
+ /** Boolean. */
95
+ static readonly BOOLEAN: IcebergType;
96
+ /** 32-bit signed integer. */
97
+ static readonly INT: IcebergType;
98
+ /** 64-bit signed integer. */
99
+ static readonly LONG: IcebergType;
100
+ /** 32-bit IEEE 754 floating point. */
101
+ static readonly FLOAT: IcebergType;
102
+ /** 64-bit IEEE 754 floating point. */
103
+ static readonly DOUBLE: IcebergType;
104
+ /** Calendar date with no time of day. */
105
+ static readonly DATE: IcebergType;
106
+ /** Microsecond-precision time of day, no date, no zone. */
107
+ static readonly TIME: IcebergType;
108
+ /** Microsecond-precision timestamp without zone. */
109
+ static readonly TIMESTAMP: IcebergType;
110
+ /** Microsecond-precision timestamp stored as UTC. */
111
+ static readonly TIMESTAMPTZ: IcebergType;
112
+ /** UTF-8 string of arbitrary length. */
113
+ static readonly STRING: IcebergType;
114
+ /** RFC-4122 UUID. */
115
+ static readonly UUID: IcebergType;
116
+ /** Variable-length byte sequence. */
117
+ static readonly BINARY: IcebergType;
118
+ /**
119
+ * Fixed-precision decimal.
120
+ * @param precision Total number of digits (1..38).
121
+ * @param scale Digits after the decimal point (0..precision).
122
+ */
123
+ static decimal(precision: number, scale: number): IcebergType;
124
+ /**
125
+ * Fixed-length byte array.
126
+ * @param length Byte length (must be positive).
127
+ */
128
+ static fixed(length: number): IcebergType;
129
+ /**
130
+ * Ordered list of values.
131
+ * @param element Element type.
132
+ * @param elementRequired Whether elements are non-nullable. Defaults to `true` (non-null).
133
+ */
134
+ static list(element: IcebergType, elementRequired?: boolean): IcebergType;
135
+ /**
136
+ * Key/value map. Keys are always required per the Iceberg spec.
137
+ * @param key Key type.
138
+ * @param value Value type.
139
+ * @param valueRequired Whether values are non-nullable. Defaults to `true` (non-null).
140
+ */
141
+ static map(key: IcebergType, value: IcebergType, valueRequired?: boolean): IcebergType;
142
+ /**
143
+ * Nested struct.
144
+ * @param fields Struct fields (each carries a name, type, required flag, optional doc).
145
+ */
146
+ static struct(fields: IcebergStructFieldDefinition[]): IcebergType;
147
+ /** Discriminator. */
148
+ readonly kind: IcebergTypeKind;
149
+ /** Decimal precision (set when `kind === DECIMAL`). */
150
+ readonly decimalPrecision?: number;
151
+ /** Decimal scale (set when `kind === DECIMAL`). */
152
+ readonly decimalScale?: number;
153
+ /** Fixed-byte length (set when `kind === FIXED`). */
154
+ readonly fixedLength?: number;
155
+ /** List element type (set when `kind === LIST`). */
156
+ readonly listElement?: IcebergType;
157
+ /** Whether list elements are non-nullable (set when `kind === LIST`). */
158
+ readonly listElementRequired?: boolean;
159
+ /** Map key type (set when `kind === MAP`). */
160
+ readonly mapKey?: IcebergType;
161
+ /** Map value type (set when `kind === MAP`). */
162
+ readonly mapValue?: IcebergType;
163
+ /** Whether map values are non-nullable (set when `kind === MAP`). */
164
+ readonly mapValueRequired?: boolean;
165
+ /** Struct fields (set when `kind === STRUCT`). */
166
+ readonly structFields?: IcebergStructFieldDefinition[];
167
+ constructor(options: IcebergTypeOptions);
168
+ /**
169
+ * Render the type as the string Glue's `IcebergStructField.type`
170
+ * expects. Primitives return their canonical name; nested types
171
+ * return a JSON-encoded object.
172
+ *
173
+ * @internal
174
+ */
175
+ _render(ctx: IcebergRenderContext): string;
176
+ /** Whether this type is the Iceberg primitive of the given canonical name. */
177
+ isPrimitive(canonical: string): boolean;
178
+ /** Whether this type is `decimal(P, S)` for any `P, S`. */
179
+ isDecimal(): boolean;
180
+ /** Whether this type is `fixed[L]` for any `L`. */
181
+ isFixed(): boolean;
182
+ }
@@ -0,0 +1,365 @@
1
+ "use strict";
2
+ /**
3
+ * Iceberg primitive and nested type representation.
4
+ *
5
+ * Iceberg field types are serialized to a string when a primitive
6
+ * (`int`, `long`, `decimal(10,2)`, ...) and to a JSON object embedded
7
+ * as a string when nested (`list`, `map`, `struct`). The Glue CFN
8
+ * surface accepts either form in `IcebergStructField.type`, so the L2
9
+ * always renders to `string`.
10
+ *
11
+ * Nested types carry their own field IDs (`element-id`, `key-id`,
12
+ * `value-id`, and per-field `id` inside structs). Those IDs must be
13
+ * globally unique inside one Iceberg table — so when `IcebergTable`
14
+ * walks its columns it threads a single monotonically-increasing
15
+ * counter through every type to assign them.
16
+ *
17
+ * `IcebergType` is intentionally jsii-friendly: one concrete class,
18
+ * discriminated by a public `kind` enum, all fields are public
19
+ * readonly so non-TypeScript bindings see the same shape, and the
20
+ * public constructor runs the same validation as the static factories
21
+ * (callers cannot reach the constructor without going through a kind
22
+ * + matching data combination).
23
+ */
24
+ Object.defineProperty(exports, "__esModule", { value: true });
25
+ exports.IcebergType = exports.IcebergTypeKind = void 0;
26
+ /** Discriminator for `IcebergType`. */
27
+ var IcebergTypeKind;
28
+ (function (IcebergTypeKind) {
29
+ IcebergTypeKind["BOOLEAN"] = "boolean";
30
+ IcebergTypeKind["INT"] = "int";
31
+ IcebergTypeKind["LONG"] = "long";
32
+ IcebergTypeKind["FLOAT"] = "float";
33
+ IcebergTypeKind["DOUBLE"] = "double";
34
+ IcebergTypeKind["DATE"] = "date";
35
+ IcebergTypeKind["TIME"] = "time";
36
+ IcebergTypeKind["TIMESTAMP"] = "timestamp";
37
+ IcebergTypeKind["TIMESTAMPTZ"] = "timestamptz";
38
+ IcebergTypeKind["STRING"] = "string";
39
+ IcebergTypeKind["UUID"] = "uuid";
40
+ IcebergTypeKind["BINARY"] = "binary";
41
+ IcebergTypeKind["DECIMAL"] = "decimal";
42
+ IcebergTypeKind["FIXED"] = "fixed";
43
+ IcebergTypeKind["LIST"] = "list";
44
+ IcebergTypeKind["MAP"] = "map";
45
+ IcebergTypeKind["STRUCT"] = "struct";
46
+ })(IcebergTypeKind || (exports.IcebergTypeKind = IcebergTypeKind = {}));
47
+ /**
48
+ * Iceberg type. Use the static factories on this class to construct
49
+ * primitives, decimals, fixed, lists, maps, and structs.
50
+ */
51
+ class IcebergType {
52
+ /// Primitives — values from https://iceberg.apache.org/spec/#schemas-and-data-types
53
+ /** Boolean. */
54
+ static BOOLEAN = new IcebergType({
55
+ kind: IcebergTypeKind.BOOLEAN,
56
+ });
57
+ /** 32-bit signed integer. */
58
+ static INT = new IcebergType({
59
+ kind: IcebergTypeKind.INT,
60
+ });
61
+ /** 64-bit signed integer. */
62
+ static LONG = new IcebergType({
63
+ kind: IcebergTypeKind.LONG,
64
+ });
65
+ /** 32-bit IEEE 754 floating point. */
66
+ static FLOAT = new IcebergType({
67
+ kind: IcebergTypeKind.FLOAT,
68
+ });
69
+ /** 64-bit IEEE 754 floating point. */
70
+ static DOUBLE = new IcebergType({
71
+ kind: IcebergTypeKind.DOUBLE,
72
+ });
73
+ /** Calendar date with no time of day. */
74
+ static DATE = new IcebergType({
75
+ kind: IcebergTypeKind.DATE,
76
+ });
77
+ /** Microsecond-precision time of day, no date, no zone. */
78
+ static TIME = new IcebergType({
79
+ kind: IcebergTypeKind.TIME,
80
+ });
81
+ /** Microsecond-precision timestamp without zone. */
82
+ static TIMESTAMP = new IcebergType({
83
+ kind: IcebergTypeKind.TIMESTAMP,
84
+ });
85
+ /** Microsecond-precision timestamp stored as UTC. */
86
+ static TIMESTAMPTZ = new IcebergType({
87
+ kind: IcebergTypeKind.TIMESTAMPTZ,
88
+ });
89
+ /** UTF-8 string of arbitrary length. */
90
+ static STRING = new IcebergType({
91
+ kind: IcebergTypeKind.STRING,
92
+ });
93
+ /** RFC-4122 UUID. */
94
+ static UUID = new IcebergType({
95
+ kind: IcebergTypeKind.UUID,
96
+ });
97
+ /** Variable-length byte sequence. */
98
+ static BINARY = new IcebergType({
99
+ kind: IcebergTypeKind.BINARY,
100
+ });
101
+ /**
102
+ * Fixed-precision decimal.
103
+ * @param precision Total number of digits (1..38).
104
+ * @param scale Digits after the decimal point (0..precision).
105
+ */
106
+ static decimal(precision, scale) {
107
+ return new IcebergType({
108
+ kind: IcebergTypeKind.DECIMAL,
109
+ decimalPrecision: precision,
110
+ decimalScale: scale,
111
+ });
112
+ }
113
+ /**
114
+ * Fixed-length byte array.
115
+ * @param length Byte length (must be positive).
116
+ */
117
+ static fixed(length) {
118
+ return new IcebergType({
119
+ kind: IcebergTypeKind.FIXED,
120
+ fixedLength: length,
121
+ });
122
+ }
123
+ /**
124
+ * Ordered list of values.
125
+ * @param element Element type.
126
+ * @param elementRequired Whether elements are non-nullable. Defaults to `true` (non-null).
127
+ */
128
+ static list(element, elementRequired = true) {
129
+ return new IcebergType({
130
+ kind: IcebergTypeKind.LIST,
131
+ listElement: element,
132
+ listElementRequired: elementRequired,
133
+ });
134
+ }
135
+ /**
136
+ * Key/value map. Keys are always required per the Iceberg spec.
137
+ * @param key Key type.
138
+ * @param value Value type.
139
+ * @param valueRequired Whether values are non-nullable. Defaults to `true` (non-null).
140
+ */
141
+ static map(key, value, valueRequired = true) {
142
+ return new IcebergType({
143
+ kind: IcebergTypeKind.MAP,
144
+ mapKey: key,
145
+ mapValue: value,
146
+ mapValueRequired: valueRequired,
147
+ });
148
+ }
149
+ /**
150
+ * Nested struct.
151
+ * @param fields Struct fields (each carries a name, type, required flag, optional doc).
152
+ */
153
+ static struct(fields) {
154
+ return new IcebergType({
155
+ kind: IcebergTypeKind.STRUCT,
156
+ structFields: fields,
157
+ });
158
+ }
159
+ /** Discriminator. */
160
+ kind;
161
+ /** Decimal precision (set when `kind === DECIMAL`). */
162
+ decimalPrecision;
163
+ /** Decimal scale (set when `kind === DECIMAL`). */
164
+ decimalScale;
165
+ /** Fixed-byte length (set when `kind === FIXED`). */
166
+ fixedLength;
167
+ /** List element type (set when `kind === LIST`). */
168
+ listElement;
169
+ /** Whether list elements are non-nullable (set when `kind === LIST`). */
170
+ listElementRequired;
171
+ /** Map key type (set when `kind === MAP`). */
172
+ mapKey;
173
+ /** Map value type (set when `kind === MAP`). */
174
+ mapValue;
175
+ /** Whether map values are non-nullable (set when `kind === MAP`). */
176
+ mapValueRequired;
177
+ /** Struct fields (set when `kind === STRUCT`). */
178
+ structFields;
179
+ constructor(options) {
180
+ this.kind = options.kind;
181
+ switch (options.kind) {
182
+ case IcebergTypeKind.DECIMAL:
183
+ if (options.decimalPrecision === undefined || options.decimalScale === undefined) {
184
+ throw new Error('decimal requires both decimalPrecision and decimalScale');
185
+ }
186
+ if (!Number.isInteger(options.decimalPrecision)
187
+ || options.decimalPrecision < 1
188
+ || options.decimalPrecision > 38) {
189
+ throw new Error(`decimal precision must be an integer in [1, 38], got ${options.decimalPrecision}`);
190
+ }
191
+ if (!Number.isInteger(options.decimalScale)
192
+ || options.decimalScale < 0
193
+ || options.decimalScale > options.decimalPrecision) {
194
+ throw new Error(`decimal scale must be an integer in [0, ${options.decimalPrecision}], got ${options.decimalScale}`);
195
+ }
196
+ this.decimalPrecision = options.decimalPrecision;
197
+ this.decimalScale = options.decimalScale;
198
+ break;
199
+ case IcebergTypeKind.FIXED:
200
+ if (options.fixedLength === undefined) {
201
+ throw new Error('fixed requires fixedLength');
202
+ }
203
+ if (!Number.isInteger(options.fixedLength) || options.fixedLength < 1) {
204
+ throw new Error(`fixed length must be a positive integer, got ${options.fixedLength}`);
205
+ }
206
+ this.fixedLength = options.fixedLength;
207
+ break;
208
+ case IcebergTypeKind.LIST:
209
+ if (options.listElement === undefined) {
210
+ throw new Error('list requires listElement');
211
+ }
212
+ this.listElement = options.listElement;
213
+ this.listElementRequired = options.listElementRequired ?? true;
214
+ break;
215
+ case IcebergTypeKind.MAP:
216
+ if (options.mapKey === undefined || options.mapValue === undefined) {
217
+ throw new Error('map requires both mapKey and mapValue');
218
+ }
219
+ this.mapKey = options.mapKey;
220
+ this.mapValue = options.mapValue;
221
+ this.mapValueRequired = options.mapValueRequired ?? true;
222
+ break;
223
+ case IcebergTypeKind.STRUCT:
224
+ if (options.structFields === undefined || options.structFields.length === 0) {
225
+ throw new Error('struct requires at least one structField');
226
+ }
227
+ /// Field names must be unique.
228
+ const seenNames = new Set();
229
+ for (const field of options.structFields) {
230
+ if (seenNames.has(field.name)) {
231
+ throw new Error(`duplicate field name in struct: ${field.name}`);
232
+ }
233
+ seenNames.add(field.name);
234
+ }
235
+ this.structFields = options.structFields;
236
+ break;
237
+ case IcebergTypeKind.BOOLEAN:
238
+ case IcebergTypeKind.INT:
239
+ case IcebergTypeKind.LONG:
240
+ case IcebergTypeKind.FLOAT:
241
+ case IcebergTypeKind.DOUBLE:
242
+ case IcebergTypeKind.DATE:
243
+ case IcebergTypeKind.TIME:
244
+ case IcebergTypeKind.TIMESTAMP:
245
+ case IcebergTypeKind.TIMESTAMPTZ:
246
+ case IcebergTypeKind.STRING:
247
+ case IcebergTypeKind.UUID:
248
+ case IcebergTypeKind.BINARY:
249
+ /// Primitives carry no extra data.
250
+ break;
251
+ /* istanbul ignore next: defensive — TS exhaustiveness covers this, only reachable from non-TS bindings */
252
+ default: {
253
+ const exhaustive = options.kind;
254
+ throw new Error(`unknown IcebergTypeKind: ${exhaustive}`);
255
+ }
256
+ }
257
+ }
258
+ /**
259
+ * Render the type as the string Glue's `IcebergStructField.type`
260
+ * expects. Primitives return their canonical name; nested types
261
+ * return a JSON-encoded object.
262
+ *
263
+ * @internal
264
+ */
265
+ _render(ctx) {
266
+ switch (this.kind) {
267
+ case IcebergTypeKind.DECIMAL:
268
+ return `decimal(${this.decimalPrecision},${this.decimalScale})`;
269
+ case IcebergTypeKind.FIXED:
270
+ return `fixed[${this.fixedLength}]`;
271
+ case IcebergTypeKind.LIST: {
272
+ const elementId = ctx.nextId();
273
+ const elementRepr = this.listElement._render(ctx);
274
+ return JSON.stringify({
275
+ type: 'list',
276
+ 'element-id': elementId,
277
+ 'element-required': this.listElementRequired,
278
+ element: tryParseObject(elementRepr),
279
+ });
280
+ }
281
+ case IcebergTypeKind.MAP: {
282
+ const keyId = ctx.nextId();
283
+ const valueId = ctx.nextId();
284
+ const keyRepr = this.mapKey._render(ctx);
285
+ const valueRepr = this.mapValue._render(ctx);
286
+ return JSON.stringify({
287
+ type: 'map',
288
+ 'key-id': keyId,
289
+ key: tryParseObject(keyRepr),
290
+ 'value-id': valueId,
291
+ 'value-required': this.mapValueRequired,
292
+ value: tryParseObject(valueRepr),
293
+ });
294
+ }
295
+ case IcebergTypeKind.STRUCT: {
296
+ const rendered = this.structFields.map((field) => {
297
+ const id = ctx.nextId();
298
+ const required = field.required ?? false;
299
+ const typeRepr = field.type._render(ctx);
300
+ const out = {
301
+ id,
302
+ name: field.name,
303
+ required,
304
+ type: tryParseObject(typeRepr),
305
+ };
306
+ if (field.doc !== undefined) {
307
+ out.doc = field.doc;
308
+ }
309
+ return out;
310
+ });
311
+ return JSON.stringify({
312
+ type: 'struct',
313
+ fields: rendered,
314
+ });
315
+ }
316
+ case IcebergTypeKind.BOOLEAN:
317
+ case IcebergTypeKind.INT:
318
+ case IcebergTypeKind.LONG:
319
+ case IcebergTypeKind.FLOAT:
320
+ case IcebergTypeKind.DOUBLE:
321
+ case IcebergTypeKind.DATE:
322
+ case IcebergTypeKind.TIME:
323
+ case IcebergTypeKind.TIMESTAMP:
324
+ case IcebergTypeKind.TIMESTAMPTZ:
325
+ case IcebergTypeKind.STRING:
326
+ case IcebergTypeKind.UUID:
327
+ case IcebergTypeKind.BINARY:
328
+ return this.kind;
329
+ /* istanbul ignore next: defensive — TS exhaustiveness covers this, only reachable from non-TS bindings */
330
+ default: {
331
+ const exhaustive = this.kind;
332
+ throw new Error(`unknown IcebergTypeKind in _render: ${exhaustive}`);
333
+ }
334
+ }
335
+ }
336
+ /** Whether this type is the Iceberg primitive of the given canonical name. */
337
+ isPrimitive(canonical) {
338
+ return this.kind === canonical;
339
+ }
340
+ /** Whether this type is `decimal(P, S)` for any `P, S`. */
341
+ isDecimal() {
342
+ return this.kind === IcebergTypeKind.DECIMAL;
343
+ }
344
+ /** Whether this type is `fixed[L]` for any `L`. */
345
+ isFixed() {
346
+ return this.kind === IcebergTypeKind.FIXED;
347
+ }
348
+ }
349
+ exports.IcebergType = IcebergType;
350
+ /**
351
+ * Parse a string as JSON if it looks like an object, otherwise return
352
+ * the string unchanged. Used so that when we embed a nested type
353
+ * representation back inside a parent JSON object the result is
354
+ * structured JSON, not a doubly-encoded string.
355
+ *
356
+ * @internal
357
+ */
358
+ function tryParseObject(repr) {
359
+ const first = repr.charAt(0);
360
+ if (first === '{' || first === '[') {
361
+ return JSON.parse(repr);
362
+ }
363
+ return repr;
364
+ }
365
+ //# sourceMappingURL=data:application/json;base64,{"version":3,"file":"iceberg-type.js","sourceRoot":"","sources":["../../../lib/iceberg/iceberg-type.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Iceberg primitive and nested type representation.\n *\n * Iceberg field types are serialized to a string when a primitive\n * (`int`, `long`, `decimal(10,2)`, ...) and to a JSON object embedded\n * as a string when nested (`list`, `map`, `struct`). The Glue CFN\n * surface accepts either form in `IcebergStructField.type`, so the L2\n * always renders to `string`.\n *\n * Nested types carry their own field IDs (`element-id`, `key-id`,\n * `value-id`, and per-field `id` inside structs). Those IDs must be\n * globally unique inside one Iceberg table — so when `IcebergTable`\n * walks its columns it threads a single monotonically-increasing\n * counter through every type to assign them.\n *\n * `IcebergType` is intentionally jsii-friendly: one concrete class,\n * discriminated by a public `kind` enum, all fields are public\n * readonly so non-TypeScript bindings see the same shape, and the\n * public constructor runs the same validation as the static factories\n * (callers cannot reach the constructor without going through a kind\n * + matching data combination).\n */\n\n/** @internal Render-time state — currently just a monotonic id generator. */\nexport interface IcebergRenderContext {\n    /** Returns the next unused field/element/key/value id. */\n    nextId(): number;\n}\n\n/** Discriminator for `IcebergType`. */\nexport enum IcebergTypeKind {\n    BOOLEAN = 'boolean',\n    INT = 'int',\n    LONG = 'long',\n    FLOAT = 'float',\n    DOUBLE = 'double',\n    DATE = 'date',\n    TIME = 'time',\n    TIMESTAMP = 'timestamp',\n    TIMESTAMPTZ = 'timestamptz',\n    STRING = 'string',\n    UUID = 'uuid',\n    BINARY = 'binary',\n    DECIMAL = 'decimal',\n    FIXED = 'fixed',\n    LIST = 'list',\n    MAP = 'map',\n    STRUCT = 'struct',\n}\n\n/** Definition of a single struct field. */\nexport interface IcebergStructFieldDefinition {\n    /** Field name (unique within the struct). */\n    readonly name: string;\n\n    /** Field type. */\n    readonly type: IcebergType;\n\n    /** Whether the field is non-nullable. Defaults to `false`. */\n    readonly required?: boolean;\n\n    /** Optional documentation string. */\n    readonly doc?: string;\n}\n\n/**\n * Construction options for an `IcebergType`.\n *\n * Most callers should use the static factories (`IcebergType.BOOLEAN`,\n * `IcebergType.list(...)`, etc.) rather than instantiate directly.\n * The constructor exists for jsii reflection; it runs the same\n * validation as the factories.\n */\nexport interface IcebergTypeOptions {\n    /** Discriminator. */\n    readonly kind: IcebergTypeKind;\n\n    /** Decimal precision (1..38). Required when `kind === DECIMAL`. */\n    readonly decimalPrecision?: number;\n\n    /** Decimal scale (0..precision). Required when `kind === DECIMAL`. */\n    readonly decimalScale?: number;\n\n    /** Fixed-byte length (positive). Required when `kind === FIXED`. */\n    readonly fixedLength?: number;\n\n    /** Element type. Required when `kind === LIST`. */\n    readonly listElement?: IcebergType;\n\n    /** Whether list elements are non-nullable. Defaults to `true`. */\n    readonly listElementRequired?: boolean;\n\n    /** Map key type. Required when `kind === MAP`. */\n    readonly mapKey?: IcebergType;\n\n    /** Map value type. Required when `kind === MAP`. */\n    readonly mapValue?: IcebergType;\n\n    /** Whether map values are non-nullable. Defaults to `true`. */\n    readonly mapValueRequired?: boolean;\n\n    /** Struct fields (non-empty, unique names). Required when `kind === STRUCT`. */\n    readonly structFields?: IcebergStructFieldDefinition[];\n}\n\n/**\n * Iceberg type. Use the static factories on this class to construct\n * primitives, decimals, fixed, lists, maps, and structs.\n */\nexport class IcebergType {\n    /// Primitives — values from https://iceberg.apache.org/spec/#schemas-and-data-types\n\n    /** Boolean. */\n    public static readonly BOOLEAN: IcebergType = new IcebergType({\n        kind: IcebergTypeKind.BOOLEAN,\n    });\n\n    /** 32-bit signed integer. */\n    public static readonly INT: IcebergType = new IcebergType({\n        kind: IcebergTypeKind.INT,\n    });\n\n    /** 64-bit signed integer. */\n    public static readonly LONG: IcebergType = new IcebergType({\n        kind: IcebergTypeKind.LONG,\n    });\n\n    /** 32-bit IEEE 754 floating point. */\n    public static readonly FLOAT: IcebergType = new IcebergType({\n        kind: IcebergTypeKind.FLOAT,\n    });\n\n    /** 64-bit IEEE 754 floating point. */\n    public static readonly DOUBLE: IcebergType = new IcebergType({\n        kind: IcebergTypeKind.DOUBLE,\n    });\n\n    /** Calendar date with no time of day. */\n    public static readonly DATE: IcebergType = new IcebergType({\n        kind: IcebergTypeKind.DATE,\n    });\n\n    /** Microsecond-precision time of day, no date, no zone. */\n    public static readonly TIME: IcebergType = new IcebergType({\n        kind: IcebergTypeKind.TIME,\n    });\n\n    /** Microsecond-precision timestamp without zone. */\n    public static readonly TIMESTAMP: IcebergType = new IcebergType({\n        kind: IcebergTypeKind.TIMESTAMP,\n    });\n\n    /** Microsecond-precision timestamp stored as UTC. */\n    public static readonly TIMESTAMPTZ: IcebergType = new IcebergType({\n        kind: IcebergTypeKind.TIMESTAMPTZ,\n    });\n\n    /** UTF-8 string of arbitrary length. */\n    public static readonly STRING: IcebergType = new IcebergType({\n        kind: IcebergTypeKind.STRING,\n    });\n\n    /** RFC-4122 UUID. */\n    public static readonly UUID: IcebergType = new IcebergType({\n        kind: IcebergTypeKind.UUID,\n    });\n\n    /** Variable-length byte sequence. */\n    public static readonly BINARY: IcebergType = new IcebergType({\n        kind: IcebergTypeKind.BINARY,\n    });\n\n    /**\n     * Fixed-precision decimal.\n     * @param precision Total number of digits (1..38).\n     * @param scale Digits after the decimal point (0..precision).\n     */\n    public static decimal(precision: number, scale: number): IcebergType {\n        return new IcebergType({\n            kind: IcebergTypeKind.DECIMAL,\n            decimalPrecision: precision,\n            decimalScale: scale,\n        });\n    }\n\n    /**\n     * Fixed-length byte array.\n     * @param length Byte length (must be positive).\n     */\n    public static fixed(length: number): IcebergType {\n        return new IcebergType({\n            kind: IcebergTypeKind.FIXED,\n            fixedLength: length,\n        });\n    }\n\n    /**\n     * Ordered list of values.\n     * @param element Element type.\n     * @param elementRequired Whether elements are non-nullable. Defaults to `true` (non-null).\n     */\n    public static list(element: IcebergType, elementRequired = true): IcebergType {\n        return new IcebergType({\n            kind: IcebergTypeKind.LIST,\n            listElement: element,\n            listElementRequired: elementRequired,\n        });\n    }\n\n    /**\n     * Key/value map. Keys are always required per the Iceberg spec.\n     * @param key Key type.\n     * @param value Value type.\n     * @param valueRequired Whether values are non-nullable. Defaults to `true` (non-null).\n     */\n    public static map(key: IcebergType, value: IcebergType, valueRequired = true): IcebergType {\n        return new IcebergType({\n            kind: IcebergTypeKind.MAP,\n            mapKey: key,\n            mapValue: value,\n            mapValueRequired: valueRequired,\n        });\n    }\n\n    /**\n     * Nested struct.\n     * @param fields Struct fields (each carries a name, type, required flag, optional doc).\n     */\n    public static struct(fields: IcebergStructFieldDefinition[]): IcebergType {\n        return new IcebergType({\n            kind: IcebergTypeKind.STRUCT,\n            structFields: fields,\n        });\n    }\n\n    /** Discriminator. */\n    public readonly kind: IcebergTypeKind;\n\n    /** Decimal precision (set when `kind === DECIMAL`). */\n    public readonly decimalPrecision?: number;\n\n    /** Decimal scale (set when `kind === DECIMAL`). */\n    public readonly decimalScale?: number;\n\n    /** Fixed-byte length (set when `kind === FIXED`). */\n    public readonly fixedLength?: number;\n\n    /** List element type (set when `kind === LIST`). */\n    public readonly listElement?: IcebergType;\n\n    /** Whether list elements are non-nullable (set when `kind === LIST`). */\n    public readonly listElementRequired?: boolean;\n\n    /** Map key type (set when `kind === MAP`). */\n    public readonly mapKey?: IcebergType;\n\n    /** Map value type (set when `kind === MAP`). */\n    public readonly mapValue?: IcebergType;\n\n    /** Whether map values are non-nullable (set when `kind === MAP`). */\n    public readonly mapValueRequired?: boolean;\n\n    /** Struct fields (set when `kind === STRUCT`). */\n    public readonly structFields?: IcebergStructFieldDefinition[];\n\n    public constructor(options: IcebergTypeOptions) {\n        this.kind = options.kind;\n        switch (options.kind) {\n            case IcebergTypeKind.DECIMAL:\n                if (options.decimalPrecision === undefined || options.decimalScale === undefined) {\n                    throw new Error('decimal requires both decimalPrecision and decimalScale');\n                }\n                if (!Number.isInteger(options.decimalPrecision)\n                    || options.decimalPrecision < 1\n                    || options.decimalPrecision > 38) {\n                    throw new Error(\n                        `decimal precision must be an integer in [1, 38], got ${options.decimalPrecision}`,\n                    );\n                }\n                if (!Number.isInteger(options.decimalScale)\n                    || options.decimalScale < 0\n                    || options.decimalScale > options.decimalPrecision) {\n                    throw new Error(\n                        `decimal scale must be an integer in [0, ${options.decimalPrecision}], got ${options.decimalScale}`,\n                    );\n                }\n                this.decimalPrecision = options.decimalPrecision;\n                this.decimalScale = options.decimalScale;\n                break;\n            case IcebergTypeKind.FIXED:\n                if (options.fixedLength === undefined) {\n                    throw new Error('fixed requires fixedLength');\n                }\n                if (!Number.isInteger(options.fixedLength) || options.fixedLength < 1) {\n                    throw new Error(`fixed length must be a positive integer, got ${options.fixedLength}`);\n                }\n                this.fixedLength = options.fixedLength;\n                break;\n            case IcebergTypeKind.LIST:\n                if (options.listElement === undefined) {\n                    throw new Error('list requires listElement');\n                }\n                this.listElement = options.listElement;\n                this.listElementRequired = options.listElementRequired ?? true;\n                break;\n            case IcebergTypeKind.MAP:\n                if (options.mapKey === undefined || options.mapValue === undefined) {\n                    throw new Error('map requires both mapKey and mapValue');\n                }\n                this.mapKey = options.mapKey;\n                this.mapValue = options.mapValue;\n                this.mapValueRequired = options.mapValueRequired ?? true;\n                break;\n            case IcebergTypeKind.STRUCT:\n                if (options.structFields === undefined || options.structFields.length === 0) {\n                    throw new Error('struct requires at least one structField');\n                }\n                /// Field names must be unique.\n                const seenNames = new Set<string>();\n                for (const field of options.structFields) {\n                    if (seenNames.has(field.name)) {\n                        throw new Error(`duplicate field name in struct: ${field.name}`);\n                    }\n                    seenNames.add(field.name);\n                }\n                this.structFields = options.structFields;\n                break;\n            case IcebergTypeKind.BOOLEAN:\n            case IcebergTypeKind.INT:\n            case IcebergTypeKind.LONG:\n            case IcebergTypeKind.FLOAT:\n            case IcebergTypeKind.DOUBLE:\n            case IcebergTypeKind.DATE:\n            case IcebergTypeKind.TIME:\n            case IcebergTypeKind.TIMESTAMP:\n            case IcebergTypeKind.TIMESTAMPTZ:\n            case IcebergTypeKind.STRING:\n            case IcebergTypeKind.UUID:\n            case IcebergTypeKind.BINARY:\n                /// Primitives carry no extra data.\n                break;\n            /* istanbul ignore next: defensive — TS exhaustiveness covers this, only reachable from non-TS bindings */\n            default: {\n                const exhaustive: never = options.kind;\n                throw new Error(`unknown IcebergTypeKind: ${exhaustive}`);\n            }\n        }\n    }\n\n    /**\n     * Render the type as the string Glue's `IcebergStructField.type`\n     * expects. Primitives return their canonical name; nested types\n     * return a JSON-encoded object.\n     *\n     * @internal\n     */\n    public _render(ctx: IcebergRenderContext): string {\n        switch (this.kind) {\n            case IcebergTypeKind.DECIMAL:\n                return `decimal(${this.decimalPrecision},${this.decimalScale})`;\n            case IcebergTypeKind.FIXED:\n                return `fixed[${this.fixedLength}]`;\n            case IcebergTypeKind.LIST: {\n                const elementId = ctx.nextId();\n                const elementRepr = this.listElement!._render(ctx);\n                return JSON.stringify({\n                    type: 'list',\n                    'element-id': elementId,\n                    'element-required': this.listElementRequired,\n                    element: tryParseObject(elementRepr),\n                });\n            }\n            case IcebergTypeKind.MAP: {\n                const keyId = ctx.nextId();\n                const valueId = ctx.nextId();\n                const keyRepr = this.mapKey!._render(ctx);\n                const valueRepr = this.mapValue!._render(ctx);\n                return JSON.stringify({\n                    type: 'map',\n                    'key-id': keyId,\n                    key: tryParseObject(keyRepr),\n                    'value-id': valueId,\n                    'value-required': this.mapValueRequired,\n                    value: tryParseObject(valueRepr),\n                });\n            }\n            case IcebergTypeKind.STRUCT: {\n                const rendered = this.structFields!.map((field) => {\n                    const id = ctx.nextId();\n                    const required = field.required ?? false;\n                    const typeRepr = field.type._render(ctx);\n                    const out: Record<string, unknown> = {\n                        id,\n                        name: field.name,\n                        required,\n                        type: tryParseObject(typeRepr),\n                    };\n                    if (field.doc !== undefined) {\n                        out.doc = field.doc;\n                    }\n                    return out;\n                });\n                return JSON.stringify({\n                    type: 'struct',\n                    fields: rendered,\n                });\n            }\n            case IcebergTypeKind.BOOLEAN:\n            case IcebergTypeKind.INT:\n            case IcebergTypeKind.LONG:\n            case IcebergTypeKind.FLOAT:\n            case IcebergTypeKind.DOUBLE:\n            case IcebergTypeKind.DATE:\n            case IcebergTypeKind.TIME:\n            case IcebergTypeKind.TIMESTAMP:\n            case IcebergTypeKind.TIMESTAMPTZ:\n            case IcebergTypeKind.STRING:\n            case IcebergTypeKind.UUID:\n            case IcebergTypeKind.BINARY:\n                return this.kind;\n            /* istanbul ignore next: defensive — TS exhaustiveness covers this, only reachable from non-TS bindings */\n            default: {\n                const exhaustive: never = this.kind;\n                throw new Error(`unknown IcebergTypeKind in _render: ${exhaustive}`);\n            }\n        }\n    }\n\n    /** Whether this type is the Iceberg primitive of the given canonical name. */\n    public isPrimitive(canonical: string): boolean {\n        return this.kind === canonical;\n    }\n\n    /** Whether this type is `decimal(P, S)` for any `P, S`. */\n    public isDecimal(): boolean {\n        return this.kind === IcebergTypeKind.DECIMAL;\n    }\n\n    /** Whether this type is `fixed[L]` for any `L`. */\n    public isFixed(): boolean {\n        return this.kind === IcebergTypeKind.FIXED;\n    }\n}\n\n/**\n * Parse a string as JSON if it looks like an object, otherwise return\n * the string unchanged. Used so that when we embed a nested type\n * representation back inside a parent JSON object the result is\n * structured JSON, not a doubly-encoded string.\n *\n * @internal\n */\nfunction tryParseObject(repr: string): unknown {\n    const first = repr.charAt(0);\n    if (first === '{' || first === '[') {\n        return JSON.parse(repr);\n    }\n    return repr;\n}\n"]}
@@ -0,0 +1,4 @@
1
+ export { IcebergType, IcebergTypeKind, IcebergTypeOptions, IcebergStructFieldDefinition, } from './iceberg-type';
2
+ export { IcebergPartitionTransform, IcebergPartitionTransformKind, IcebergPartitionTransformOptions, } from './iceberg-partition-transform';
3
+ export { IcebergDataFormat, IcebergFormatVersion, ICEBERG_PROPERTY_KEYS, } from './iceberg-table-properties';
4
+ export { IcebergColumn, IcebergNullOrder, IcebergPartitionField, IcebergSortDirection, IcebergSortField, IcebergTable, IcebergTableAttributes, IcebergTableProps, IIcebergTable, } from './iceberg-table';
@@ -0,0 +1,18 @@
1
+ "use strict";
2
+ Object.defineProperty(exports, "__esModule", { value: true });
3
+ exports.IcebergTable = exports.IcebergSortDirection = exports.IcebergNullOrder = exports.ICEBERG_PROPERTY_KEYS = exports.IcebergFormatVersion = exports.IcebergDataFormat = exports.IcebergPartitionTransformKind = exports.IcebergPartitionTransform = exports.IcebergTypeKind = exports.IcebergType = void 0;
4
+ var iceberg_type_1 = require("./iceberg-type");
5
+ Object.defineProperty(exports, "IcebergType", { enumerable: true, get: function () { return iceberg_type_1.IcebergType; } });
6
+ Object.defineProperty(exports, "IcebergTypeKind", { enumerable: true, get: function () { return iceberg_type_1.IcebergTypeKind; } });
7
+ var iceberg_partition_transform_1 = require("./iceberg-partition-transform");
8
+ Object.defineProperty(exports, "IcebergPartitionTransform", { enumerable: true, get: function () { return iceberg_partition_transform_1.IcebergPartitionTransform; } });
9
+ Object.defineProperty(exports, "IcebergPartitionTransformKind", { enumerable: true, get: function () { return iceberg_partition_transform_1.IcebergPartitionTransformKind; } });
10
+ var iceberg_table_properties_1 = require("./iceberg-table-properties");
11
+ Object.defineProperty(exports, "IcebergDataFormat", { enumerable: true, get: function () { return iceberg_table_properties_1.IcebergDataFormat; } });
12
+ Object.defineProperty(exports, "IcebergFormatVersion", { enumerable: true, get: function () { return iceberg_table_properties_1.IcebergFormatVersion; } });
13
+ Object.defineProperty(exports, "ICEBERG_PROPERTY_KEYS", { enumerable: true, get: function () { return iceberg_table_properties_1.ICEBERG_PROPERTY_KEYS; } });
14
+ var iceberg_table_1 = require("./iceberg-table");
15
+ Object.defineProperty(exports, "IcebergNullOrder", { enumerable: true, get: function () { return iceberg_table_1.IcebergNullOrder; } });
16
+ Object.defineProperty(exports, "IcebergSortDirection", { enumerable: true, get: function () { return iceberg_table_1.IcebergSortDirection; } });
17
+ Object.defineProperty(exports, "IcebergTable", { enumerable: true, get: function () { return iceberg_table_1.IcebergTable; } });
18
+ //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9saWIvaWNlYmVyZy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFBQSwrQ0FLd0I7QUFKcEIsMkdBQUEsV0FBVyxPQUFBO0FBQ1gsK0dBQUEsZUFBZSxPQUFBO0FBSW5CLDZFQUl1QztBQUhuQyx3SUFBQSx5QkFBeUIsT0FBQTtBQUN6Qiw0SUFBQSw2QkFBNkIsT0FBQTtBQUdqQyx1RUFJb0M7QUFIaEMsNkhBQUEsaUJBQWlCLE9BQUE7QUFDakIsZ0lBQUEsb0JBQW9CLE9BQUE7QUFDcEIsaUlBQUEscUJBQXFCLE9BQUE7QUFFekIsaURBVXlCO0FBUnJCLGlIQUFBLGdCQUFnQixPQUFBO0FBRWhCLHFIQUFBLG9CQUFvQixPQUFBO0FBRXBCLDZHQUFBLFlBQVksT0FBQSIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCB7XG4gICAgSWNlYmVyZ1R5cGUsXG4gICAgSWNlYmVyZ1R5cGVLaW5kLFxuICAgIEljZWJlcmdUeXBlT3B0aW9ucyxcbiAgICBJY2ViZXJnU3RydWN0RmllbGREZWZpbml0aW9uLFxufSBmcm9tICcuL2ljZWJlcmctdHlwZSc7XG5leHBvcnQge1xuICAgIEljZWJlcmdQYXJ0aXRpb25UcmFuc2Zvcm0sXG4gICAgSWNlYmVyZ1BhcnRpdGlvblRyYW5zZm9ybUtpbmQsXG4gICAgSWNlYmVyZ1BhcnRpdGlvblRyYW5zZm9ybU9wdGlvbnMsXG59IGZyb20gJy4vaWNlYmVyZy1wYXJ0aXRpb24tdHJhbnNmb3JtJztcbmV4cG9ydCB7XG4gICAgSWNlYmVyZ0RhdGFGb3JtYXQsXG4gICAgSWNlYmVyZ0Zvcm1hdFZlcnNpb24sXG4gICAgSUNFQkVSR19QUk9QRVJUWV9LRVlTLFxufSBmcm9tICcuL2ljZWJlcmctdGFibGUtcHJvcGVydGllcyc7XG5leHBvcnQge1xuICAgIEljZWJlcmdDb2x1bW4sXG4gICAgSWNlYmVyZ051bGxPcmRlcixcbiAgICBJY2ViZXJnUGFydGl0aW9uRmllbGQsXG4gICAgSWNlYmVyZ1NvcnREaXJlY3Rpb24sXG4gICAgSWNlYmVyZ1NvcnRGaWVsZCxcbiAgICBJY2ViZXJnVGFibGUsXG4gICAgSWNlYmVyZ1RhYmxlQXR0cmlidXRlcyxcbiAgICBJY2ViZXJnVGFibGVQcm9wcyxcbiAgICBJSWNlYmVyZ1RhYmxlLFxufSBmcm9tICcuL2ljZWJlcmctdGFibGUnO1xuIl19