Skip to content

Commit e963895

Browse files
kuhekuhe
committed
fix(util-dynamodb): fix signature overload resolution for marshall() fn
1 parent 4759f6a commit e963895

File tree

3 files changed

+202
-43
lines changed

3 files changed

+202
-43
lines changed

‎packages/util-dynamodb/src/marshall.spec.ts

Lines changed: 146 additions & 35 deletions
Original file line numberDiff line numberDiff line change
@@ -1,33 +1,26 @@
11
import { AttributeValue } from "@aws-sdk/client-dynamodb";
22

3-
import { convertToAttr } from "./convertToAttr";
43
import { marshall } from "./marshall";
5-
6-
jest.mock("./convertToAttr");
4+
import { NumberValue } from "./NumberValue";
75

86
describe("marshall", () => {
9-
const mockOutput = { S: "mockOutput" };
10-
(convertToAttr as jest.Mock).mockReturnValue({ M: mockOutput });
11-
12-
afterEach(() => {
13-
jest.clearAllMocks();
14-
});
15-
167
it("with object as an input", () => {
178
const input = { a: "A", b: "B" };
18-
expect(marshall(input)).toEqual(mockOutput);
19-
expect(convertToAttr).toHaveBeenCalledTimes(1);
20-
expect(convertToAttr).toHaveBeenCalledWith(input, undefined);
9+
expect(marshall(input)).toEqual({
10+
a: { S: "A" },
11+
b: { S: "B" },
12+
});
2113
});
2214

2315
["convertEmptyValues", "removeUndefinedValues"].forEach((option) => {
2416
describe(`options.${option}`, () => {
2517
[false, true].forEach((value) => {
2618
it(`passes ${value} to convertToAttr`, () => {
2719
const input = { a: "A", b: "B" };
28-
expect(marshall(input, { [option]: value })).toEqual(mockOutput);
29-
expect(convertToAttr).toHaveBeenCalledTimes(1);
30-
expect(convertToAttr).toHaveBeenCalledWith(input, { [option]: value });
20+
expect(marshall(input, { [option]: value })).toEqual({
21+
a: { S: "A" },
22+
b: { S: "B" },
23+
});
3124
});
3225
});
3326
});
@@ -37,9 +30,10 @@ describe("marshall", () => {
3730
type TestInputType = { a: string; b: string };
3831
const input: TestInputType = { a: "A", b: "B" };
3932

40-
expect(marshall(input)).toEqual(mockOutput);
41-
expect(convertToAttr).toHaveBeenCalledTimes(1);
42-
expect(convertToAttr).toHaveBeenCalledWith(input, undefined);
33+
expect(marshall(input)).toEqual({
34+
a: { S: "A" },
35+
b: { S: "B" },
36+
});
4337
});
4438

4539
it("with Interface as an input", () => {
@@ -49,29 +43,145 @@ describe("marshall", () => {
4943
}
5044
const input: TestInputInterface = { a: "A", b: "B" };
5145

52-
expect(marshall(input)).toEqual(mockOutput);
53-
expect(convertToAttr).toHaveBeenCalledTimes(1);
54-
expect(convertToAttr).toHaveBeenCalledWith(input, undefined);
46+
expect(marshall(input)).toEqual({
47+
a: { S: "A" },
48+
b: { S: "B" },
49+
});
5550
});
5651

5752
it("should resolve signatures correctly", () => {
58-
// eslint-disable @typescript-eslint/no-unused-vars
5953
const ss: AttributeValue.SSMember = marshall(new Set(["a"]));
54+
expect(ss).toEqual({
55+
SS: ["a"],
56+
} as AttributeValue.SSMember);
6057
const ns: AttributeValue.NSMember = marshall(new Set([0]));
61-
const bs: AttributeValue.BSMember = marshall(new Set([new Uint8Array()]));
58+
expect(ns).toEqual({
59+
NS: ["0"],
60+
} as AttributeValue.NSMember);
61+
const bs: AttributeValue.BSMember = marshall(new Set([new Uint8Array(4)]));
62+
expect(bs).toEqual({
63+
BS: [new Uint8Array(4)],
64+
} as AttributeValue.BSMember);
6265
const s: AttributeValue.SMember = marshall("a");
63-
const n: AttributeValue.NMember = marshall(0);
66+
expect(s).toEqual({
67+
S: "a",
68+
} as AttributeValue.SMember);
69+
const n1: AttributeValue.NMember = marshall(0);
70+
expect(n1).toEqual({ N: "0" } as AttributeValue.NMember);
71+
const n2: AttributeValue.NMember = marshall(BigInt(0));
72+
expect(n2).toEqual({ N: "0" } as AttributeValue.NMember);
73+
const n3: AttributeValue.NMember = marshall(NumberValue.from(0));
74+
expect(n3).toEqual({ N: "0" } as AttributeValue.NMember);
75+
const binary: AttributeValue.BMember = marshall(new Uint8Array(4));
76+
expect(binary).toEqual({
77+
B: new Uint8Array(4),
78+
} as AttributeValue.BMember);
6479
const nil: AttributeValue.NULLMember = marshall(null);
65-
const bool: AttributeValue.BOOLMember = marshall(false);
66-
const array: AttributeValue[] = marshall([]);
67-
const object: Record<string, AttributeValue> = marshall({
80+
expect(nil).toEqual({
81+
NULL: true,
82+
} as AttributeValue.NULLMember);
83+
const bool: AttributeValue.BOOLMember = marshall(false as boolean);
84+
expect(bool).toEqual({
85+
BOOL: false,
86+
} as AttributeValue.BOOLMember);
87+
const array: AttributeValue[] = marshall([1, 2, 3]);
88+
expect(array).toEqual([{ N: "1" }, { N: "2" }, { N: "3" }] as AttributeValue.NMember[]);
89+
const arrayLDefault: AttributeValue[] = marshall([1, 2, 3], {});
90+
expect(arrayLDefault).toEqual([{ N: "1" }, { N: "2" }, { N: "3" }] as AttributeValue.NMember[]);
91+
const arrayLFalse: AttributeValue[] = marshall([1, 2, 3], {
92+
convertTopLevelContainer: false,
93+
});
94+
expect(arrayLFalse).toEqual([{ N: "1" }, { N: "2" }, { N: "3" }] as AttributeValue.NMember[]);
95+
const arrayLTrue: AttributeValue.LMember = marshall([1, 2, 3], {
96+
convertTopLevelContainer: true,
97+
});
98+
expect(arrayLTrue).toEqual({
99+
L: [{ N: "1" }, { N: "2" }, { N: "3" }],
100+
} as AttributeValue.LMember);
101+
const arrayLBoolean: AttributeValue.LMember | AttributeValue[] = marshall([1, 2, 3], {
102+
convertTopLevelContainer: true as boolean,
103+
});
104+
expect(arrayLBoolean).toEqual({
105+
L: [{ N: "1" }, { N: "2" }, { N: "3" }],
106+
} as AttributeValue.LMember);
107+
const object1: Record<string, AttributeValue> = marshall({
68108
pk: "abc",
69109
sk: "xyz",
70110
});
71-
const unrecognizedClassInstance1: Record<string, AttributeValue> = marshall(new Map());
72-
const unrecognizedClassInstance2: Record<string, AttributeValue> = marshall(new Date());
73-
const unrecognizedNonClassInstanceValue: AttributeValue.$UnknownMember = marshall(BigInt(0));
74-
// eslint-enable @typescript-eslint/no-unused-vars
111+
expect(object1).toEqual({
112+
pk: { S: "abc" },
113+
sk: { S: "xyz" },
114+
} as Record<string, AttributeValue.SMember>);
115+
const object2: Record<string, AttributeValue> = marshall(
116+
{
117+
pk: "abc",
118+
sk: "xyz",
119+
},
120+
{}
121+
);
122+
expect(object2).toEqual({
123+
pk: { S: "abc" },
124+
sk: { S: "xyz" },
125+
} as Record<string, AttributeValue.SMember>);
126+
const object3: AttributeValue.MMember = marshall(
127+
{
128+
pk: "abc",
129+
sk: "xyz",
130+
},
131+
{ convertTopLevelContainer: true }
132+
);
133+
expect(object3).toEqual({
134+
M: {
135+
pk: { S: "abc" },
136+
sk: { S: "xyz" },
137+
},
138+
} as AttributeValue.MMember);
139+
const object4: Record<string, AttributeValue> | AttributeValue.MMember = marshall(
140+
{
141+
pk: "abc",
142+
sk: "xyz",
143+
},
144+
{ convertTopLevelContainer: true as boolean }
145+
);
146+
expect(object4).toEqual({
147+
M: {
148+
pk: { S: "abc" },
149+
sk: { S: "xyz" },
150+
},
151+
} as AttributeValue.MMember);
152+
const map: Record<string, AttributeValue> = marshall(new Map([["a", "a"]]));
153+
expect(map).toEqual({
154+
a: { S: "a" },
155+
} as Record<string, AttributeValue.SMember>);
156+
const unrecognizedClassInstance: Record<string, AttributeValue> = marshall(new Date(), {
157+
convertClassInstanceToMap: true,
158+
});
159+
expect(unrecognizedClassInstance).toEqual({} as Record<string, AttributeValue>);
160+
const unrecognizedClassInstance2: Record<string, AttributeValue> = marshall(
161+
new (class {
162+
public a = "a";
163+
public b = "b";
164+
})(),
165+
{
166+
convertClassInstanceToMap: true,
167+
}
168+
);
169+
expect(unrecognizedClassInstance2).toEqual({
170+
a: { S: "a" },
171+
b: { S: "b" },
172+
} as Record<string, AttributeValue>);
173+
174+
// this strange cast asserts that untyped fallback results in the `any` type.
175+
const untyped: Symbol = marshall(null as any) as Symbol;
176+
expect(untyped).toEqual({
177+
NULL: true,
178+
});
179+
180+
const empty: Record<string, AttributeValue> = marshall({} as {});
181+
expect(empty).toEqual({} as Record<string, AttributeValue>);
182+
183+
const empty2: AttributeValue.MMember = marshall({} as {}, { convertTopLevelContainer: true });
184+
expect(empty2).toEqual({ M: {} } as AttributeValue.MMember);
75185
});
76186

77187
it("with class instance as an input", () => {
@@ -80,8 +190,9 @@ describe("marshall", () => {
80190
}
81191
const input = new TestInputClass("A", "B");
82192

83-
expect(marshall(input)).toEqual(mockOutput);
84-
expect(convertToAttr).toHaveBeenCalledTimes(1);
85-
expect(convertToAttr).toHaveBeenCalledWith(input, undefined);
193+
expect(marshall(input, { convertClassInstanceToMap: true })).toEqual({
194+
a: { S: "A" },
195+
b: { S: "B" },
196+
});
86197
});
87198
});

‎packages/util-dynamodb/src/marshall.ts

Lines changed: 40 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -2,6 +2,7 @@ import { AttributeValue } from "@aws-sdk/client-dynamodb";
22

33
import { convertToAttr } from "./convertToAttr";
44
import { NativeAttributeBinary, NativeAttributeValue } from "./models";
5+
import { NumberValue } from "./NumberValue";
56

67
/**
78
* An optional configuration object for `marshall`
@@ -36,19 +37,51 @@ export interface marshallOptions {
3637
* @param options - An optional configuration object for `marshall`
3738
*
3839
*/
40+
export function marshall(data: null, options?: marshallOptions): AttributeValue.NULLMember;
41+
export function marshall(
42+
data: Set<bigint> | Set<number> | Set<NumberValue>,
43+
options?: marshallOptions
44+
): AttributeValue.NSMember;
3945
export function marshall(data: Set<string>, options?: marshallOptions): AttributeValue.SSMember;
40-
export function marshall(data: Set<number>, options?: marshallOptions): AttributeValue.NSMember;
4146
export function marshall(data: Set<NativeAttributeBinary>, options?: marshallOptions): AttributeValue.BSMember;
42-
export function marshall(data: string, options?: marshallOptions): AttributeValue.SMember;
43-
export function marshall(data: number, options?: marshallOptions): AttributeValue.NMember;
4447
export function marshall(data: NativeAttributeBinary, options?: marshallOptions): AttributeValue.BMember;
45-
export function marshall(data: null, options?: marshallOptions): AttributeValue.NULLMember;
4648
export function marshall(data: boolean, options?: marshallOptions): AttributeValue.BOOLMember;
47-
export function marshall<L extends NativeAttributeValue[]>(data: L, options?: marshallOptions): AttributeValue[];
48-
export function marshall<M extends Record<string, NativeAttributeValue>>(
49-
data: M,
49+
export function marshall(data: number | NumberValue | bigint, options?: marshallOptions): AttributeValue.NMember;
50+
export function marshall(data: string, options?: marshallOptions): AttributeValue.SMember;
51+
export function marshall(data: boolean, options?: marshallOptions): AttributeValue.BOOLMember;
52+
export function marshall<O extends { convertTopLevelContainer: true }>(
53+
data: NativeAttributeValue[],
54+
options: marshallOptions & O
55+
): AttributeValue.LMember;
56+
export function marshall<O extends { convertTopLevelContainer: false }>(
57+
data: NativeAttributeValue[],
58+
options: marshallOptions & O
59+
): AttributeValue[];
60+
export function marshall<O extends { convertTopLevelContainer: boolean }>(
61+
data: NativeAttributeValue[],
62+
options: marshallOptions & O
63+
): AttributeValue[] | AttributeValue.LMember;
64+
export function marshall(data: NativeAttributeValue[], options?: marshallOptions): AttributeValue[];
65+
export function marshall<O extends { convertTopLevelContainer: true }>(
66+
data: Map<string, NativeAttributeValue> | Record<string, NativeAttributeValue>,
67+
options: marshallOptions & O
68+
): AttributeValue.MMember;
69+
export function marshall<O extends { convertTopLevelContainer: false }>(
70+
data: Map<string, NativeAttributeValue> | Record<string, NativeAttributeValue>,
71+
options: marshallOptions & O
72+
): Record<string, AttributeValue>;
73+
export function marshall<O extends { convertTopLevelContainer: boolean }>(
74+
data: Map<string, NativeAttributeValue> | Record<string, NativeAttributeValue>,
75+
options: marshallOptions & O
76+
): Record<string, AttributeValue> | AttributeValue.MMember;
77+
export function marshall(
78+
data: Map<string, NativeAttributeValue> | Record<string, NativeAttributeValue>,
5079
options?: marshallOptions
5180
): Record<string, AttributeValue>;
81+
export function marshall(data: any, options?: marshallOptions): any;
82+
/**
83+
* This signature is will be unmatchable but is included for information.
84+
*/
5285
export function marshall(data: unknown, options?: marshallOptions): AttributeValue.$UnknownMember;
5386
export function marshall(data: unknown, options?: marshallOptions) {
5487
const attributeValue: AttributeValue = convertToAttr(data, options);

‎packages/util-dynamodb/src/models.ts

Lines changed: 16 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1,3 +1,5 @@
1+
import type { Exact } from "@smithy/types";
2+
13
/**
24
* A interface recognizable as a numeric value that stores the underlying number
35
* as a string.
@@ -10,13 +12,19 @@ export interface NumberValue {
1012
readonly value: string;
1113
}
1214

15+
/**
16+
* @public
17+
*/
1318
export type NativeAttributeValue =
1419
| NativeScalarAttributeValue
1520
| { [key: string]: NativeAttributeValue }
1621
| NativeAttributeValue[]
1722
| Set<number | bigint | NumberValue | string | NativeAttributeBinary | undefined>
1823
| InstanceType<{ new (...args: any[]): any }>; // accepts any class instance with options.convertClassInstanceToMap
1924

25+
/**
26+
* @public
27+
*/
2028
export type NativeScalarAttributeValue =
2129
| null
2230
| undefined
@@ -36,9 +44,16 @@ declare global {
3644
interface File {}
3745
}
3846

47+
type Unavailable = never;
48+
type BlobDefined = Exact<Blob, {}> extends true ? false : true;
49+
type BlobOptionalType = BlobDefined extends true ? Blob : Unavailable;
50+
51+
/**
52+
* @public
53+
*/
3954
export type NativeAttributeBinary =
4055
| ArrayBuffer
41-
| Blob
56+
| BlobOptionalType
4257
| Buffer
4358
| DataView
4459
| File

0 commit comments

Comments
 (0)