fix(sam): Reduce SAM schema size (#283)

Author: kddejong

src/schema/SamSchemaTransformer.ts

@@ -50,9 +50,10 @@ export const SamSchemaTransformer = {
                 string,
                 unknown
             >;
+            let propertiesRefKey: string | undefined;
             if (propertiesSchema?.$ref) {
-                const refKey = (propertiesSchema.$ref as string).replace('#/definitions/', '');
-                propertiesSchema = samSchema.definitions[refKey] as Record<string, unknown>;
+                propertiesRefKey = (propertiesSchema.$ref as string).replace('#/definitions/', '');
+                propertiesSchema = samSchema.definitions[propertiesRefKey] as Record<string, unknown>;
             }
 
             const cfnSchema: CloudFormationResourceSchema = {
@@ -63,7 +64,7 @@ export const SamSchemaTransformer = {
                     (propertiesSchema?.properties as Record<string, unknown>) ?? {},
                     samSchema.definitions,
                 ),
-                definitions: samSchema.definitions,
+                definitions: this.extractReferencedDefinitions(definition, samSchema.definitions, defKey),
                 additionalProperties: false,
                 required: (propertiesSchema?.required as string[]) ?? [],
                 attributes: {}, // Empty to avoid GetAtt issues
@@ -79,6 +80,47 @@ export const SamSchemaTransformer = {
         return resourceSchemas;
     },
 
+    extractReferencedDefinitions(
+        schema: Record<string, unknown> | undefined,
+        allDefinitions: Record<string, unknown>,
+        rootDefinitionKey?: string,
+    ): Record<string, unknown> {
+        const referenced = new Set<string>();
+        const result: Record<string, unknown> = {};
+
+        // Include the root definition if provided
+        if (rootDefinitionKey && allDefinitions[rootDefinitionKey]) {
+            referenced.add(rootDefinitionKey);
+            result[rootDefinitionKey] = allDefinitions[rootDefinitionKey];
+        }
+
+        const collectRefs = (obj: unknown): void => {
+            if (typeof obj === 'object' && obj !== null) {
+                if (Array.isArray(obj)) {
+                    for (const item of obj) {
+                        collectRefs(item);
+                    }
+                } else {
+                    const record = obj as Record<string, unknown>;
+                    if (record.$ref && typeof record.$ref === 'string') {
+                        const refKey = record.$ref.replace('#/definitions/', '');
+                        if (!referenced.has(refKey) && allDefinitions[refKey]) {
+                            referenced.add(refKey);
+                            result[refKey] = allDefinitions[refKey];
+                            collectRefs(allDefinitions[refKey]);
+                        }
+                    }
+                    for (const value of Object.values(record)) {
+                        collectRefs(value);
+                    }
+                }
+            }
+        };
+
+        collectRefs(schema);
+        return result;
+    },
+
     resolvePropertyTypes(
         properties: Record<string, unknown>,
         definitions: Record<string, unknown>,
@@ -98,6 +140,18 @@ export const SamSchemaTransformer = {
             property = { ...property, description: property.markdownDescription };
         }
 
+        // Convert SAM's non-standard additionalProperties usage to CloudFormation-compliant patternProperties
+        if (property.additionalProperties && typeof property.additionalProperties === 'object') {
+            const additionalProps = property.additionalProperties as Record<string, unknown>;
+            property = {
+                ...property,
+                additionalProperties: false,
+                patternProperties: {
+                    '.*': additionalProps,
+                },
+            };
+        }
+
         // If property already has a type, keep it
         if (property.type) {
             return property;

tst/unit/schema/SamSchemaTransformer.test.ts

@@ -74,12 +74,95 @@ describe('SamSchemaTransformer', () => {
         const result = SamSchemaTransformer.transformSamSchema(mockSamSchema);
         const functionSchema = result.get('AWS::Serverless::Function')!;
 
-        // Verify all definitions are included
+        // Verify only referenced definitions are included (full reference chain)
         expect(functionSchema.definitions).toBeDefined();
-        expect(functionSchema.definitions).toEqual(mockSamSchema.definitions);
+
+        const expectedDefinitions = {
+            aws_serverless_functionResource: {
+                properties: {
+                    Type: { enum: ['AWS::Serverless::Function'] },
+                    Properties: { $ref: '#/definitions/FunctionProperties' },
+                },
+            },
+            FunctionProperties: {
+                properties: {
+                    Runtime: { type: 'string' },
+                    CodeUri: { $ref: '#/definitions/CodeUriType' },
+                },
+            },
+            CodeUriType: {
+                type: 'string',
+            },
+        };
+
+        expect(functionSchema.definitions).toEqual(expectedDefinitions);
 
         // This ensures $refs like { $ref: '#/definitions/CodeUriType' } will work
         expect(functionSchema.definitions!.CodeUriType).toEqual({ type: 'string' });
-        expect(functionSchema.definitions!.SomeOtherDefinition).toEqual({ type: 'object' });
+        // SomeOtherDefinition should not be included as it's not referenced
+        expect(functionSchema.definitions!.SomeOtherDefinition).toBeUndefined();
+    });
+
+    test('should handle deep nested references and convert additionalProperties', () => {
+        const mockSamSchema = {
+            properties: {
+                Resources: {
+                    additionalProperties: {
+                        anyOf: [{ $ref: '#/definitions/aws_serverless_functionResource' }],
+                    },
+                },
+            },
+            definitions: {
+                aws_serverless_functionResource: {
+                    properties: {
+                        Type: { enum: ['AWS::Serverless::Function'] },
+                        Properties: { $ref: '#/definitions/FunctionProperties' },
+                    },
+                },
+                FunctionProperties: {
+                    properties: {
+                        Events: {
+                            additionalProperties: { $ref: '#/definitions/EventDefinition' },
+                            type: 'object',
+                        },
+                    },
+                },
+                EventDefinition: {
+                    properties: {
+                        Properties: { $ref: '#/definitions/EventProperties' },
+                    },
+                },
+                EventProperties: {
+                    properties: {
+                        Auth: { $ref: '#/definitions/ApiAuth' },
+                    },
+                },
+                ApiAuth: {
+                    properties: {
+                        ApiKeyRequired: { type: 'boolean' },
+                    },
+                },
+                UnusedDefinition: { type: 'string' },
+            },
+        };
+
+        const result = SamSchemaTransformer.transformSamSchema(mockSamSchema);
+        const functionSchema = result.get('AWS::Serverless::Function')!;
+
+        // Should include all definitions in the nested chain
+        expect(functionSchema.definitions!.aws_serverless_functionResource).toBeDefined();
+        expect(functionSchema.definitions!.FunctionProperties).toBeDefined();
+        expect(functionSchema.definitions!.EventDefinition).toBeDefined();
+        expect(functionSchema.definitions!.EventProperties).toBeDefined();
+        expect(functionSchema.definitions!.ApiAuth).toBeDefined();
+
+        // Should exclude unused definition
+        expect(functionSchema.definitions!.UnusedDefinition).toBeUndefined();
+
+        // Should convert additionalProperties to patternProperties
+        const eventsProperty = functionSchema.properties.Events as any;
+        expect(eventsProperty.additionalProperties).toBe(false);
+        expect(eventsProperty.patternProperties).toBeDefined();
+        expect(eventsProperty.patternProperties['.*']).toEqual({ $ref: '#/definitions/EventDefinition' });
     });
 });