Merge pull request #23 from moznion/change_lenient_opt

moznion · web-flow · commit 70f3f27bf536 · 2022-11-20T18:50:40.000-08:00
Give "lenient type check" option through the function argument
diff --git a/README.md b/README.md
@@ -187,11 +187,11 @@ NOTE: if the TypeScript property has `unknown` type and the value is `null` then
 
 ## Options
 
-### `TS_DYNAMODB_ATTR_TRANSFORMER_LENIENT_TYPE_CHECK` env var (default: `<empty>`)
+### Lenient type checking (default: `false`)
 
 By default, if this plugin encounters unsupported types, it raises the error and halts the transformation.
 
-But if `TS_DYNAMODB_ATTR_TRANSFORMER_LENIENT_TYPE_CHECK` environment variable is not empty, it proceeds the transformation with ignoring the unsupported typed property even if it gets the unsupported types.
+But if `true` value is given through the second argument of the function, it proceeds the transformation with ignoring the unsupported typed property even if it gets the unsupported types.
 
 ## Note
 
diff --git a/index.d.ts b/index.d.ts
@@ -1,4 +1,10 @@
 import { AttributeValue } from '@aws-sdk/client-dynamodb';
 
-export function dynamodbRecord<T extends object>(item: T): Record<keyof T, AttributeValue>;
-export function fromDynamodbRecord<T extends object>(attrs: Record<string, AttributeValue>): T;
+export function dynamodbRecord<T extends object>(
+  item: T,
+  shouldLenientTypeCheck?: boolean,
+): Record<keyof T, AttributeValue>;
+export function fromDynamodbRecord<T extends object>(
+  attrs: Record<string, AttributeValue>,
+  shouldLenientTypeCheck?: boolean,
+): T;
diff --git a/lib/dynamodb_record_transformer.ts b/lib/dynamodb_record_transformer.ts
@@ -3,7 +3,6 @@ import { FieldsCollector } from './fields_collector';
 
 export class DynamodbRecordTransformer {
   public static readonly funcName = 'dynamodbRecord';
-  private static readonly shouldLenientTypeCheck = !!process.env['TS_DYNAMODB_ATTR_TRANSFORMER_LENIENT_TYPE_CHECK']; // TODO
 
   public static visitNode(node: ts.CallExpression, typeChecker: ts.TypeChecker): ts.Node | undefined {
     if (node.typeArguments === undefined || node.typeArguments.length !== 1 || !node.typeArguments[0]) {
@@ -14,12 +13,14 @@ export class DynamodbRecordTransformer {
 
     const typeArg = node.typeArguments[0];
     const typeName = typeArg.getText();
-    if (node.arguments.length !== 1 || !node.arguments[0]) {
+    if (node.arguments.length < 1 || !node.arguments[0]) {
       throw new Error(
         `No argument on ${DynamodbRecordTransformer.funcName}(). Please put an argument that has ${typeName} type on the function`,
       );
     }
 
+    const shouldLenientTypeCheck = node.arguments[1]?.getText() === 'true';
+
     const type = typeChecker.getTypeFromTypeNode(typeArg);
     if (!type.isClassOrInterface()) {
       throw new Error(
@@ -28,10 +29,7 @@ export class DynamodbRecordTransformer {
     }
 
     const argVarNameIdent = ts.factory.createIdentifier('arg');
-    const objectProps = new FieldsCollector(
-      DynamodbRecordTransformer.funcName,
-      DynamodbRecordTransformer.shouldLenientTypeCheck,
-    )
+    const objectProps = new FieldsCollector(DynamodbRecordTransformer.funcName, shouldLenientTypeCheck)
       .collectFields(node, typeChecker, typeName, type)
       .map(field => {
         return field?.generateCode(argVarNameIdent.text);
diff --git a/lib/fields_collector.ts b/lib/fields_collector.ts
@@ -29,7 +29,7 @@ export class FieldsCollector {
       throw new Error(`No type argument on ${this.funcName}(). Please put a type argument on the function`);
     }
 
-    if (node.arguments.length !== 1 || !node.arguments[0]) {
+    if (node.arguments.length < 1 || !node.arguments[0]) {
       throw new Error(
         `No argument on ${this.funcName}(). Please put an argument that has ${typeName} type on the function`,
       );
diff --git a/lib/from_dynamodb_record_transformer.ts b/lib/from_dynamodb_record_transformer.ts
@@ -3,7 +3,6 @@ import { FieldsCollector } from './fields_collector';
 
 export class FromDynamodbRecordTransformer {
   public static readonly funcName = 'fromDynamodbRecord';
-  private static readonly shouldLenientTypeCheck = !!process.env['TS_DYNAMODB_ATTR_TRANSFORMER_LENIENT_TYPE_CHECK']; // TODO
 
   public static visitNode(node: ts.CallExpression, typeChecker: ts.TypeChecker): ts.Node | undefined {
     if (node.typeArguments === undefined || node.typeArguments.length !== 1 || !node.typeArguments[0]) {
@@ -14,12 +13,14 @@ export class FromDynamodbRecordTransformer {
 
     const typeArg = node.typeArguments[0];
     const typeName = typeArg.getText();
-    if (node.arguments.length !== 1 || !node.arguments[0]) {
+    if (node.arguments.length < 1 || !node.arguments[0]) {
       throw new Error(
         `No argument on ${FromDynamodbRecordTransformer.funcName}(). Please put an argument that has ${typeName} type on the function`,
       );
     }
 
+    const shouldLenientTypeCheck = node.arguments[1]?.getText() === 'true';
+
     const type = typeChecker.getTypeFromTypeNode(typeArg);
     if (!type.isClassOrInterface()) {
       throw new Error(
@@ -33,10 +34,7 @@ export class FromDynamodbRecordTransformer {
     }
 
     const argVarNameIdent = ts.factory.createIdentifier('arg');
-    const objectProps = new FieldsCollector(
-      FromDynamodbRecordTransformer.funcName,
-      FromDynamodbRecordTransformer.shouldLenientTypeCheck,
-    )
+    const objectProps = new FieldsCollector(FromDynamodbRecordTransformer.funcName, shouldLenientTypeCheck)
       .collectFields(node, typeChecker, typeName, type)
       .map(field => {
         return field?.generateCodeForUnmarshal(argVarNameIdent.text);
diff --git a/package.json b/package.json
@@ -6,7 +6,7 @@
   "types": "index.d.ts",
   "scripts": {
     "build": "tsc",
-    "test": "TS_DYNAMODB_ATTR_TRANSFORMER_LENIENT_TYPE_CHECK=true jest --no-cache",
+    "test": "jest --no-cache",
     "fmt": "find -name '*.ts' -not -path './node_modules/*' | xargs prettier --write",
     "lint": "eslint .",
     "release": "npm run build && npm publish"
diff --git a/tests/from_dynamodb_record_transformer.test.ts b/tests/from_dynamodb_record_transformer.test.ts
@@ -29,119 +29,122 @@ describe('from dynamodb record transform', () => {
       readonly kvMapToNull: { [key: string]: unknown };
     }
 
-    const got = fromDynamodbRecord<Interface>({
-      publicNum: { N: '123' },
-      readonlyNum: { N: '234' },
-      string: { S: 'str' },
-      bytes: { B: new TextEncoder().encode('bytes') },
-      bool: { BOOL: true },
-      nil: { NULL: true },
-      stringSlice: { L: [{ S: 'slice' }, { S: 'str' }] },
-      stringArray: { L: [{ S: 'array' }, { S: 'str' }] },
-      numSlice: { L: [{ N: '123' }, { N: '234' }] },
-      numArray: { L: [{ N: '345' }, { N: '456' }] },
-      numSet: { NS: ['123', '234'] },
-      stringSet: { SS: ['set', 'str'] },
-      bytesSet: { BS: [new TextEncoder().encode('set'), new TextEncoder().encode('bytes')] },
-      mapToNum: {
-        M: {
-          mapTo: { N: '123' },
-          num: {
-            N: '234',
+    const got = fromDynamodbRecord<Interface>(
+      {
+        publicNum: { N: '123' },
+        readonlyNum: { N: '234' },
+        string: { S: 'str' },
+        bytes: { B: new TextEncoder().encode('bytes') },
+        bool: { BOOL: true },
+        nil: { NULL: true },
+        stringSlice: { L: [{ S: 'slice' }, { S: 'str' }] },
+        stringArray: { L: [{ S: 'array' }, { S: 'str' }] },
+        numSlice: { L: [{ N: '123' }, { N: '234' }] },
+        numArray: { L: [{ N: '345' }, { N: '456' }] },
+        numSet: { NS: ['123', '234'] },
+        stringSet: { SS: ['set', 'str'] },
+        bytesSet: { BS: [new TextEncoder().encode('set'), new TextEncoder().encode('bytes')] },
+        mapToNum: {
+          M: {
+            mapTo: { N: '123' },
+            num: {
+              N: '234',
+            },
           },
         },
-      },
-      mapToString: {
-        M: {
-          mapTo: {
-            S: 'foo',
-          },
-          str: {
-            S: 'bar',
+        mapToString: {
+          M: {
+            mapTo: {
+              S: 'foo',
+            },
+            str: {
+              S: 'bar',
+            },
           },
         },
-      },
-      mapToBytes: {
-        M: {
-          mapTo: {
-            B: new TextEncoder().encode('foo'),
-          },
-          bytes: {
-            B: new TextEncoder().encode('bar'),
+        mapToBytes: {
+          M: {
+            mapTo: {
+              B: new TextEncoder().encode('foo'),
+            },
+            bytes: {
+              B: new TextEncoder().encode('bar'),
+            },
           },
         },
-      },
-      mapToBool: {
-        M: {
-          mapTo: {
-            BOOL: true,
-          },
-          bool: {
-            BOOL: false,
+        mapToBool: {
+          M: {
+            mapTo: {
+              BOOL: true,
+            },
+            bool: {
+              BOOL: false,
+            },
           },
         },
-      },
-      mapToNull: {
-        M: {
-          mapTo: {
-            NULL: false,
-          },
-          null: {
-            NULL: true,
+        mapToNull: {
+          M: {
+            mapTo: {
+              NULL: false,
+            },
+            null: {
+              NULL: true,
+            },
           },
         },
-      },
-      kvMapToNum: {
-        M: {
-          kvMapTo: {
-            N: '123',
-          },
-          num: {
-            N: '234',
+        kvMapToNum: {
+          M: {
+            kvMapTo: {
+              N: '123',
+            },
+            num: {
+              N: '234',
+            },
           },
         },
-      },
-      kvMapToString: {
-        M: {
-          kvMapTo: {
-            S: 'foo',
-          },
-          str: {
-            S: 'bar',
+        kvMapToString: {
+          M: {
+            kvMapTo: {
+              S: 'foo',
+            },
+            str: {
+              S: 'bar',
+            },
           },
         },
-      },
-      kvMapToBytes: {
-        M: {
-          kvMapTo: {
-            B: new TextEncoder().encode('foo'),
-          },
-          bytes: {
-            B: new TextEncoder().encode('bar'),
+        kvMapToBytes: {
+          M: {
+            kvMapTo: {
+              B: new TextEncoder().encode('foo'),
+            },
+            bytes: {
+              B: new TextEncoder().encode('bar'),
+            },
           },
         },
-      },
-      kvMapToBool: {
-        M: {
-          kvMapTo: {
-            BOOL: true,
-          },
-          bool: {
-            BOOL: false,
+        kvMapToBool: {
+          M: {
+            kvMapTo: {
+              BOOL: true,
+            },
+            bool: {
+              BOOL: false,
+            },
           },
         },
-      },
-      kvMapToNull: {
-        M: {
-          kvMapTo: {
-            NULL: false,
-          },
-          null: {
-            NULL: true,
+        kvMapToNull: {
+          M: {
+            kvMapTo: {
+              NULL: false,
+            },
+            null: {
+              NULL: true,
+            },
           },
         },
       },
-    });
+      true,
+    );
 
     expect(got.publicNum).toEqual(123);
     expect(got.readonlyNum).toEqual(234);
@@ -215,14 +218,17 @@ describe('from dynamodb record transform', () => {
       readonly kvMapToBigint: { [key: string]: BigInt };
     }
 
-    const got = fromDynamodbRecord<Interface>({
-      bigint: { N: '123' },
-      bigintSlice: { L: [{ N: '123' }, { N: '234' }] },
-      bigintArray: { L: [{ N: '345' }, { N: '456' }] },
-      bigintSet: { NS: ['567', '678'] },
-      mapToBigint: { M: { bigint: { N: '789' } } },
-      kvMapToBigint: { M: { bigint: { N: '890' } } },
-    });
+    const got = fromDynamodbRecord<Interface>(
+      {
+        bigint: { N: '123' },
+        bigintSlice: { L: [{ N: '123' }, { N: '234' }] },
+        bigintArray: { L: [{ N: '345' }, { N: '456' }] },
+        bigintSet: { NS: ['567', '678'] },
+        mapToBigint: { M: { bigint: { N: '789' } } },
+        kvMapToBigint: { M: { bigint: { N: '890' } } },
+      },
+      true,
+    );
     expect(got.bigint).toEqual(BigInt(123));
     expect(got.bigintSlice).toEqual([BigInt(123), BigInt(234)]);
     expect(got.bigintArray).toEqual(new Array<BigInt>(BigInt(345), BigInt(456)));
diff --git a/tests/from_dynamodb_record_transformer_error.test.ts b/tests/from_dynamodb_record_transformer_error.test.ts
@@ -6,7 +6,7 @@ describe('from dynamodb record transformation errors', () => {
   test('should raise error when the type parameter is missing', async () => {
     const err = await new Promise<ExecException | null>(resolve => {
       child_process.exec(
-        'NODE_NO_WARNINGS=true TS_DYNAMODB_ATTR_TRANSFORMER_LENIENT_TYPE_CHECK= npx ts-node -C ttypescript ./tests/from_dynamodb_record_transformer_error_src/no_type_parameter.ts',
+        'NODE_NO_WARNINGS=true npx ts-node -C ttypescript ./tests/from_dynamodb_record_transformer_error_src/no_type_parameter.ts',
         err => {
           resolve(err);
         },
@@ -22,7 +22,7 @@ describe('from dynamodb record transformation errors', () => {
   test('should raise error when the type parameter is class', async () => {
     const err = await new Promise<ExecException | null>(resolve => {
       child_process.exec(
-        'NODE_NO_WARNINGS=true TS_DYNAMODB_ATTR_TRANSFORMER_LENIENT_TYPE_CHECK= npx ts-node -C ttypescript ./tests/from_dynamodb_record_transformer_error_src/class_type_parameter.ts',
+        'NODE_NO_WARNINGS=true npx ts-node -C ttypescript ./tests/from_dynamodb_record_transformer_error_src/class_type_parameter.ts',
         err => {
           resolve(err);
         },
@@ -38,7 +38,7 @@ describe('from dynamodb record transformation errors', () => {
   test('should raise error when the type parameter is not class and interface', async () => {
     const err = await new Promise<ExecException | null>(resolve => {
       child_process.exec(
-        'NODE_NO_WARNINGS=true TS_DYNAMODB_ATTR_TRANSFORMER_LENIENT_TYPE_CHECK= npx ts-node -C ttypescript ./tests/from_dynamodb_record_transformer_error_src/object_literal_type_parameter.ts',
+        'NODE_NO_WARNINGS=true npx ts-node -C ttypescript ./tests/from_dynamodb_record_transformer_error_src/object_literal_type_parameter.ts',
         err => {
           resolve(err);
         },
diff --git a/tests/transformation_error.test.ts b/tests/transformation_error.test.ts
diff --git a/tests/transformer.test.ts b/tests/transformer.test.ts

Original file line number	Diff line number	Diff line change
`@@ -29,7 +29,7 @@ export class FieldsCollector {`
`29`	`29`	throw new Error(`No type argument on ${this.funcName}(). Please put a type argument on the function`);
`30`	`30`	`}`
`31`	`31`
`32`		`- if (node.arguments.length !== 1 \|\| !node.arguments[0]) {`
	`32`	`+ if (node.arguments.length < 1 \|\| !node.arguments[0]) {`
`33`	`33`	`throw new Error(`
`34`	`34`	`No argument on ${this.funcName}(). Please put an argument that has ${typeName} type on the function`,
`35`	`35`	`);`