enable projection expressions in scan command

src/v1/commands/getItem/getItemParams/parseGetItemOptions.ts

@@ -4,10 +4,10 @@ import isEmpty from 'lodash.isempty'
 import { parseCapacityOption } from 'v1/commands/utils/parseOptions/parseCapacityOption'
 import { rejectExtraOptions } from 'v1/commands/utils/parseOptions/rejectExtraOptions'
 import { parseConsistentOption } from 'v1/commands/utils/parseOptions/parseConsistentOption'
+import { parseProjection } from 'v1/commands/expression/projection/parse'
 import { EntityV2 } from 'v1/entity'
 
 import type { GetItemOptions } from '../options'
-import { parseProjection } from '../projection'
 
 type CommandOptions = Omit<GetCommandInput, 'TableName' | 'Key'>
 

src/v1/commands/index.ts

@@ -10,5 +10,5 @@ export { ScanCommand } from './scan'
 export type { ScanOptions, ScanResponse } from './scan'
 export { formatSavedItem } from './utils/formatSavedItem'
 export { parseCondition } from './expression/condition/parse'
-export { parseProjection } from './getItem/projection'
+export { parseProjection } from './expression/projection/parse'
 export * from './types'

src/v1/commands/scan/options.ts

@@ -15,7 +15,7 @@ export type ScanOptions<ENTITIES extends EntityV2 = EntityV2> = {
   limit?: number
   filters?: EntityV2 extends ENTITIES
     ? Record<string, Condition>
-    : { [ENTITY in ENTITIES as ENTITY['name']]: Condition<ENTITY> }
+    : { [ENTITY in ENTITIES as ENTITY['name']]?: Condition<ENTITY> }
 } & (
   | { segment?: never; totalSegments?: never }
   // Either both segment & totalSegments are set, either none
@@ -32,7 +32,7 @@ export type ScanOptions<ENTITIES extends EntityV2 = EntityV2> = {
     | {
         attributes: EntityV2 extends ENTITIES
           ? Record<string, Condition>
-          : { [ENTITY in ENTITIES as ENTITY['name']]: AnyAttributePath<ENTITY>[] }
+          : { [ENTITY in ENTITIES as ENTITY['name']]?: AnyAttributePath<ENTITY>[] }
         select?: SpecificAttributesSelectOption
       }
   )

src/v1/commands/scan/scanParams/scanParams.ts

@@ -12,6 +12,7 @@ import { parseLimitOption } from 'v1/commands/utils/parseOptions/parseLimitOptio
 import { rejectExtraOptions } from 'v1/commands/utils/parseOptions/rejectExtraOptions'
 import { isInteger } from 'v1/utils/validation/isInteger'
 import { parseCondition } from 'v1/commands/expression/condition/parse'
+import { parseProjection } from 'v1/commands/expression/projection/parse'
 
 import type { ScanOptions } from '../options'
 
@@ -131,24 +132,43 @@ export const scanParams = <
     const expressionAttributeNames: Record<string, string> = {}
     const expressionAttributeValues: Record<string, any> = {}
     const filterExpressions: string[] = []
+    const projectionExpressions: string[] = []
 
     entities.forEach((entity, index) => {
       const entityNameFilter = { attr: entity.entityAttributeName, eq: entity.name }
       const entityFilter = filters[entity.name]
 
       const {
-        ExpressionAttributeNames,
-        ExpressionAttributeValues,
-        ConditionExpression
+        ExpressionAttributeNames: filterExpressionAttributeNames,
+        ExpressionAttributeValues: filterExpressionAttributeValues,
+        ConditionExpression: filterExpression
       } = parseCondition<EntityV2, Condition<EntityV2>>(
         entity,
         entityFilter !== undefined ? { and: [entityNameFilter, entityFilter] } : entityNameFilter,
         index.toString()
       )
 
-      Object.assign(expressionAttributeNames, ExpressionAttributeNames)
-      Object.assign(expressionAttributeValues, ExpressionAttributeValues)
-      filterExpressions.push(ConditionExpression)
+      Object.assign(expressionAttributeNames, filterExpressionAttributeNames)
+      Object.assign(expressionAttributeValues, filterExpressionAttributeValues)
+      filterExpressions.push(filterExpression)
+
+      const entityAttributes = attributes[entity.name]
+      if (entityAttributes !== undefined) {
+        /**
+         * @debt refactor "Would be better to have a single attribute list for all entities (typed as the intersection of all entities AnyAttributePath) but parseProjection is designed to work with entities so it's a big rework. Will do that later."
+         */
+        const {
+          ExpressionAttributeNames: projectionExpressionAttributeNames,
+          ProjectionExpression: projectionExpression
+        } = parseProjection<EntityV2, AnyAttributePath[]>(
+          entity,
+          entityAttributes,
+          index.toString()
+        )
+
+        Object.assign(expressionAttributeNames, projectionExpressionAttributeNames)
+        projectionExpressions.push(projectionExpression)
+      }
     })
 
     if (!isEmpty(expressionAttributeNames)) {
@@ -165,6 +185,10 @@ export const scanParams = <
           ? filterExpressions[0]
           : `(${filterExpressions.filter(Boolean).join(') OR (')})`
     }
+
+    if (projectionExpressions.length > 0) {
+      commandOptions.ProjectionExpression = projectionExpressions.filter(Boolean).join(', ')
+    }
   }
 
   rejectExtraOptions(extraOptions)

src/v1/commands/scan/scanParams/scanParams.unit.test.ts

@@ -437,6 +437,39 @@ describe('scan', () => {
     })
   })
 
+  it('applies entity projection expression', () => {
+    const { ProjectionExpression, ExpressionAttributeNames } = TestTable.build(ScanCommand)
+      .entities(Entity1)
+      .options({ attributes: { entity1: ['age', 'name'] } })
+      .params()
+
+    expect(ProjectionExpression).toBe('#p0_1, #p0_2')
+    expect(ExpressionAttributeNames).toMatchObject({
+      '#p0_1': 'age',
+      '#p0_2': 'name'
+    })
+  })
+
+  it('applies two entity projection expressions', () => {
+    const { ProjectionExpression, ExpressionAttributeNames } = TestTable.build(ScanCommand)
+      .entities(Entity1, Entity2)
+      .options({
+        attributes: {
+          entity1: ['age', 'name'],
+          entity2: ['price', 'launchDate']
+        }
+      })
+      .params()
+
+    expect(ProjectionExpression).toBe('#p0_1, #p0_2, #p1_1, #p1_2')
+    expect(ExpressionAttributeNames).toMatchObject({
+      '#p0_1': 'age',
+      '#p0_2': 'name',
+      '#p1_1': 'price',
+      '#p1_2': 'launchDate'
+    })
+  })
+
   it('fails on extra options', () => {
     const invalidCall = () =>
       TestTable.build(ScanCommand)