Prohibit unmarshalling for not Interface type parameters

Signed-off-by: moznion <moznion@mail.moznion.net>

Author: moznion

jest.config.js

@@ -10,4 +10,5 @@ module.exports = {
       },
     ],
   },
+  testTimeout: 10000,
 };

lib/dynamodb_record_transformer.ts

@@ -12,19 +12,27 @@ export class DynamodbRecordTransformer {
       );
     }
 
-    const typeName = node.typeArguments[0].getText();
+    const typeArg = node.typeArguments[0];
+    const typeName = typeArg.getText();
     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 type = typeChecker.getTypeFromTypeNode(typeArg);
+    if (!type.isClassOrInterface()) {
+      throw new Error(
+        `A type parameter of ${DynamodbRecordTransformer.funcName}() must be class or interface, but ${typeName} is not`,
+      );
+    }
+
     const argVarNameIdent = ts.factory.createIdentifier('arg');
     const objectProps = new FieldsCollector(
       DynamodbRecordTransformer.funcName,
       DynamodbRecordTransformer.shouldLenientTypeCheck,
     )
-      .collectFields(node, typeChecker)
+      .collectFields(node, typeChecker, typeName, type)
       .map(field => {
         return field?.generateCode(argVarNameIdent.text);
       })

lib/fields_collector.ts

@@ -17,21 +17,22 @@ import { warn } from './logger';
 export class FieldsCollector {
   constructor(private readonly funcName: string, private readonly shouldLenientTypeCheck: boolean) {}
 
-  public collectFields(node: ts.CallExpression, typeChecker: ts.TypeChecker): (DynamodbItemField | undefined)[] {
+  public collectFields(
+    node: ts.CallExpression,
+    typeChecker: ts.TypeChecker,
+    typeName: string,
+    type: ts.Type,
+  ): (DynamodbItemField | undefined)[] {
     if (node.typeArguments === undefined || node.typeArguments.length !== 1 || !node.typeArguments[0]) {
       throw new Error(`No type argument on ${this.funcName}(). Please put a type argument on the function`);
     }
 
-    const typ = node.typeArguments[0];
-    const typeName = typ.getText();
-
     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`,
       );
     }
 
-    const type = typeChecker.getTypeFromTypeNode(typ);
     const properties = typeChecker.getPropertiesOfType(type);
     return properties.map((prop): DynamodbItemField | undefined => {
       if (

lib/from_dynamodb_record_transformer.ts

@@ -12,19 +12,32 @@ export class FromDynamodbRecordTransformer {
       );
     }
 
-    const typeName = node.typeArguments[0].getText();
+    const typeArg = node.typeArguments[0];
+    const typeName = typeArg.getText();
     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 type = typeChecker.getTypeFromTypeNode(typeArg);
+    if (!type.isClassOrInterface()) {
+      throw new Error(
+        `A type parameter of ${FromDynamodbRecordTransformer.funcName}() must be interface, but ${typeName} is not`,
+      );
+    }
+    if (type.isClass()) {
+      throw new Error(
+        `A type parameter of ${FromDynamodbRecordTransformer.funcName}() must be interface, but ${typeName} is a class`,
+      );
+    }
+
     const argVarNameIdent = ts.factory.createIdentifier('arg');
     const objectProps = new FieldsCollector(
       FromDynamodbRecordTransformer.funcName,
       FromDynamodbRecordTransformer.shouldLenientTypeCheck,
     )
-      .collectFields(node, typeChecker)
+      .collectFields(node, typeChecker, typeName, type)
       .map(field => {
         return field?.generateCodeForUnmarshal(argVarNameIdent.text);
       })

tests/from_dynamodb_record_transformer.test.ts

@@ -2,7 +2,7 @@ import { describe, expect, test } from '@jest/globals';
 import { fromDynamodbRecord } from '../index';
 
 describe('from dynamodb record transform', () => {
-  test('TODO', () => {
+  test('should unmarshal the attributes into arbitrary interface instance', () => {
     interface Interface {
       publicNum: number;
       readonly readonlyNum: number;

tests/from_dynamodb_record_transformer_error.test.ts

@@ -0,0 +1,53 @@
+import { describe, expect, test } from '@jest/globals';
+import * as child_process from 'child_process';
+import { ExecException } from 'child_process';
+
+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',
+        err => {
+          resolve(err);
+        },
+      );
+    });
+
+    expect(err).not.toBeNull();
+    expect(err?.message).toMatch(
+      /Error: No type argument on fromDynamodbRecord\(\)\. Please put a type argument on the function/,
+    );
+  });
+
+  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',
+        err => {
+          resolve(err);
+        },
+      );
+    });
+
+    expect(err).not.toBeNull();
+    expect(err?.message).toMatch(
+      /Error: A type parameter of fromDynamodbRecord\(\) must be interface, but Clazz is a class/,
+    );
+  });
+
+  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',
+        err => {
+          resolve(err);
+        },
+      );
+    });
+
+    expect(err).not.toBeNull();
+    expect(err?.message).toMatch(
+      /Error: A type parameter of fromDynamodbRecord\(\) must be interface, but \{\} is not/,
+    );
+  });
+});

tests/from_dynamodb_record_transformer_error_src/class_type_parameter.ts

@@ -0,0 +1,5 @@
+import { fromDynamodbRecord } from '../../index';
+
+class Clazz {}
+
+fromDynamodbRecord<Clazz>({});

tests/from_dynamodb_record_transformer_error_src/no_type_parameter.ts

@@ -0,0 +1,3 @@
+import { fromDynamodbRecord } from '../../index';
+
+fromDynamodbRecord({});

tests/from_dynamodb_record_transformer_error_src/object_literal_type_parameter.ts

@@ -0,0 +1,3 @@
+import { fromDynamodbRecord } from '../../index';
+
+fromDynamodbRecord<{}>({});

tests/transformation_error.test.ts

@@ -19,6 +19,22 @@ describe('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/transformation_error_src/object_literal_type_parameter.ts',
+        err => {
+          resolve(err);
+        },
+      );
+    });
+
+    expect(err).not.toBeNull();
+    expect(err?.message).toMatch(
+      /Error: A type parameter of dynamodbRecord\(\) must be class or interface, but \{\} is not/,
+    );
+  });
+
   test('should raise error when the argument is missing', async () => {
     const err = await new Promise<ExecException | null>(resolve => {
       child_process.exec(