@friggframework/devtools 2.0.0--canary.461.8cf93ae.0 → 2.0.0--canary.474.aa465e4.0

package/infrastructure/domains/shared/types/discovery-result.js

@@ -0,0 +1,106 @@
+/**
+ * @fileoverview Discovery result types
+ *
+ * Defines the structure of resource discovery results.
+ * Discovery reports FACTS - it doesn't make ownership decisions.
+ */
+
+/**
+ * Resource that exists in our CloudFormation stack
+ * @typedef {Object} StackManagedResource
+ * @property {string} logicalId - CloudFormation logical resource ID (e.g., 'FriggLambdaSecurityGroup')
+ * @property {string} physicalId - AWS physical resource ID (e.g., 'sg-069629001ade41c9a')
+ * @property {string} resourceType - CloudFormation resource type (e.g., 'AWS::EC2::SecurityGroup')
+ * @property {Object} [properties] - Resource properties (optional, for detailed info)
+ */
+
+/**
+ * Resource that exists outside our CloudFormation stack
+ * @typedef {Object} ExternalResource
+ * @property {string} physicalId - AWS physical resource ID
+ * @property {string} resourceType - CloudFormation resource type
+ * @property {'tag-search' | 'name-search' | 'aws-api' | 'user-provided'} source - How it was discovered
+ * @property {Object} [properties] - Resource properties (optional)
+ * @property {Object} [tags] - Resource tags (if available)
+ */
+
+/**
+ * Complete discovery result
+ * @typedef {Object} DiscoveryResult
+ * @property {StackManagedResource[]} stackManaged - Resources in OUR CloudFormation stack
+ * @property {ExternalResource[]} external - Resources outside our stack
+ * @property {string} [stackName] - Name of our CloudFormation stack (if exists)
+ * @property {boolean} fromCloudFormation - Whether stack was found in CloudFormation
+ * @property {string} [region] - AWS region
+ * @property {Object} [metadata] - Additional discovery metadata
+ */
+
+/**
+ * Create empty discovery result
+ * @returns {DiscoveryResult}
+ */
+function createEmptyDiscoveryResult() {
+    return {
+        stackManaged: [],
+        external: [],
+        fromCloudFormation: false
+    };
+}
+
+/**
+ * Find stack-managed resource by logical ID
+ * @param {DiscoveryResult} discovery - Discovery result
+ * @param {string} logicalId - Logical resource ID to find
+ * @returns {StackManagedResource|null}
+ */
+function findStackResource(discovery, logicalId) {
+    return discovery.stackManaged.find(r => r.logicalId === logicalId) || null;
+}
+
+/**
+ * Find external resource by type
+ * @param {DiscoveryResult} discovery - Discovery result
+ * @param {string} resourceType - CloudFormation resource type
+ * @returns {ExternalResource|null}
+ */
+function findExternalResource(discovery, resourceType) {
+    return discovery.external.find(r => r.resourceType === resourceType) || null;
+}
+
+/**
+ * Find all external resources by type
+ * @param {DiscoveryResult} discovery - Discovery result
+ * @param {string} resourceType - CloudFormation resource type
+ * @returns {ExternalResource[]}
+ */
+function findAllExternalResources(discovery, resourceType) {
+    return discovery.external.filter(r => r.resourceType === resourceType);
+}
+
+/**
+ * Check if specific resource exists in stack
+ * @param {DiscoveryResult} discovery - Discovery result
+ * @param {string} logicalId - Logical resource ID
+ * @returns {boolean}
+ */
+function isResourceInStack(discovery, logicalId) {
+    return discovery.stackManaged.some(r => r.logicalId === logicalId);
+}
+
+/**
+ * Get all stack logical IDs
+ * @param {DiscoveryResult} discovery - Discovery result
+ * @returns {string[]}
+ */
+function getStackLogicalIds(discovery) {
+    return discovery.stackManaged.map(r => r.logicalId);
+}
+
+module.exports = {
+    createEmptyDiscoveryResult,
+    findStackResource,
+    findExternalResource,
+    findAllExternalResources,
+    isResourceInStack,
+    getStackLogicalIds
+};

package/infrastructure/domains/shared/types/discovery-result.test.js

@@ -0,0 +1,258 @@
+const {
+    createEmptyDiscoveryResult,
+    findStackResource,
+    findExternalResource,
+    findAllExternalResources,
+    isResourceInStack,
+    getStackLogicalIds
+} = require('./discovery-result');
+
+describe('Discovery Result Utilities', () => {
+    describe('createEmptyDiscoveryResult', () => {
+        it('should create empty discovery result with correct structure', () => {
+            const result = createEmptyDiscoveryResult();
+
+            expect(result).toEqual({
+                stackManaged: [],
+                external: [],
+                fromCloudFormation: false
+            });
+        });
+    });
+
+    describe('findStackResource', () => {
+        it('should find resource by logical ID', () => {
+            const discovery = {
+                stackManaged: [
+                    { logicalId: 'FriggVPC', physicalId: 'vpc-123', resourceType: 'AWS::EC2::VPC' },
+                    { logicalId: 'FriggLambdaSecurityGroup', physicalId: 'sg-456', resourceType: 'AWS::EC2::SecurityGroup' }
+                ],
+                external: [],
+                fromCloudFormation: true
+            };
+
+            const found = findStackResource(discovery, 'FriggLambdaSecurityGroup');
+
+            expect(found).toEqual({
+                logicalId: 'FriggLambdaSecurityGroup',
+                physicalId: 'sg-456',
+                resourceType: 'AWS::EC2::SecurityGroup'
+            });
+        });
+
+        it('should return null if resource not found', () => {
+            const discovery = {
+                stackManaged: [
+                    { logicalId: 'FriggVPC', physicalId: 'vpc-123', resourceType: 'AWS::EC2::VPC' }
+                ],
+                external: [],
+                fromCloudFormation: true
+            };
+
+            const found = findStackResource(discovery, 'NonExistent');
+
+            expect(found).toBeNull();
+        });
+
+        it('should return null for empty stack managed resources', () => {
+            const discovery = createEmptyDiscoveryResult();
+            const found = findStackResource(discovery, 'FriggVPC');
+
+            expect(found).toBeNull();
+        });
+    });
+
+    describe('findExternalResource', () => {
+        it('should find external resource by type', () => {
+            const discovery = {
+                stackManaged: [],
+                external: [
+                    { physicalId: 'vpc-external', resourceType: 'AWS::EC2::VPC', source: 'tag-search' },
+                    { physicalId: 'sg-external', resourceType: 'AWS::EC2::SecurityGroup', source: 'tag-search' }
+                ],
+                fromCloudFormation: false
+            };
+
+            const found = findExternalResource(discovery, 'AWS::EC2::SecurityGroup');
+
+            expect(found).toEqual({
+                physicalId: 'sg-external',
+                resourceType: 'AWS::EC2::SecurityGroup',
+                source: 'tag-search'
+            });
+        });
+
+        it('should return null if external resource not found', () => {
+            const discovery = createEmptyDiscoveryResult();
+            const found = findExternalResource(discovery, 'AWS::EC2::VPC');
+
+            expect(found).toBeNull();
+        });
+
+        it('should return first match if multiple resources of same type', () => {
+            const discovery = {
+                stackManaged: [],
+                external: [
+                    { physicalId: 'subnet-1', resourceType: 'AWS::EC2::Subnet', source: 'tag-search' },
+                    { physicalId: 'subnet-2', resourceType: 'AWS::EC2::Subnet', source: 'tag-search' }
+                ],
+                fromCloudFormation: false
+            };
+
+            const found = findExternalResource(discovery, 'AWS::EC2::Subnet');
+
+            expect(found.physicalId).toBe('subnet-1');
+        });
+    });
+
+    describe('findAllExternalResources', () => {
+        it('should find all external resources of given type', () => {
+            const discovery = {
+                stackManaged: [],
+                external: [
+                    { physicalId: 'subnet-1', resourceType: 'AWS::EC2::Subnet', source: 'tag-search' },
+                    { physicalId: 'subnet-2', resourceType: 'AWS::EC2::Subnet', source: 'tag-search' },
+                    { physicalId: 'sg-1', resourceType: 'AWS::EC2::SecurityGroup', source: 'tag-search' }
+                ],
+                fromCloudFormation: false
+            };
+
+            const found = findAllExternalResources(discovery, 'AWS::EC2::Subnet');
+
+            expect(found).toHaveLength(2);
+            expect(found[0].physicalId).toBe('subnet-1');
+            expect(found[1].physicalId).toBe('subnet-2');
+        });
+
+        it('should return empty array if no resources found', () => {
+            const discovery = createEmptyDiscoveryResult();
+            const found = findAllExternalResources(discovery, 'AWS::EC2::VPC');
+
+            expect(found).toEqual([]);
+        });
+    });
+
+    describe('isResourceInStack', () => {
+        it('should return true if resource is in stack', () => {
+            const discovery = {
+                stackManaged: [
+                    { logicalId: 'FriggVPC', physicalId: 'vpc-123', resourceType: 'AWS::EC2::VPC' },
+                    { logicalId: 'FriggLambdaSecurityGroup', physicalId: 'sg-456', resourceType: 'AWS::EC2::SecurityGroup' }
+                ],
+                external: [],
+                fromCloudFormation: true
+            };
+
+            expect(isResourceInStack(discovery, 'FriggVPC')).toBe(true);
+            expect(isResourceInStack(discovery, 'FriggLambdaSecurityGroup')).toBe(true);
+        });
+
+        it('should return false if resource is not in stack', () => {
+            const discovery = {
+                stackManaged: [
+                    { logicalId: 'FriggVPC', physicalId: 'vpc-123', resourceType: 'AWS::EC2::VPC' }
+                ],
+                external: [],
+                fromCloudFormation: true
+            };
+
+            expect(isResourceInStack(discovery, 'NonExistent')).toBe(false);
+        });
+
+        it('should return false for empty stack', () => {
+            const discovery = createEmptyDiscoveryResult();
+
+            expect(isResourceInStack(discovery, 'FriggVPC')).toBe(false);
+        });
+    });
+
+    describe('getStackLogicalIds', () => {
+        it('should return all logical IDs from stack', () => {
+            const discovery = {
+                stackManaged: [
+                    { logicalId: 'FriggVPC', physicalId: 'vpc-123', resourceType: 'AWS::EC2::VPC' },
+                    { logicalId: 'FriggLambdaSecurityGroup', physicalId: 'sg-456', resourceType: 'AWS::EC2::SecurityGroup' },
+                    { logicalId: 'FriggAuroraCluster', physicalId: 'cluster-789', resourceType: 'AWS::RDS::DBCluster' }
+                ],
+                external: [],
+                fromCloudFormation: true
+            };
+
+            const ids = getStackLogicalIds(discovery);
+
+            expect(ids).toEqual([
+                'FriggVPC',
+                'FriggLambdaSecurityGroup',
+                'FriggAuroraCluster'
+            ]);
+        });
+
+        it('should return empty array for empty stack', () => {
+            const discovery = createEmptyDiscoveryResult();
+            const ids = getStackLogicalIds(discovery);
+
+            expect(ids).toEqual([]);
+        });
+    });
+
+    describe('real-world scenarios', () => {
+        it('scenario: fresh deploy, no stack exists', () => {
+            const discovery = createEmptyDiscoveryResult();
+
+            expect(discovery.fromCloudFormation).toBe(false);
+            expect(discovery.stackManaged).toHaveLength(0);
+            expect(discovery.external).toHaveLength(0);
+
+            expect(isResourceInStack(discovery, 'FriggVPC')).toBe(false);
+            expect(findStackResource(discovery, 'FriggVPC')).toBeNull();
+        });
+
+        it('scenario: redeploy existing stack', () => {
+            const discovery = {
+                stackManaged: [
+                    { logicalId: 'FriggVPC', physicalId: 'vpc-123', resourceType: 'AWS::EC2::VPC' },
+                    { logicalId: 'FriggLambdaSecurityGroup', physicalId: 'sg-069629001ade41c9a', resourceType: 'AWS::EC2::SecurityGroup' },
+                    { logicalId: 'FriggPrivateSubnet1', physicalId: 'subnet-1', resourceType: 'AWS::EC2::Subnet' },
+                    { logicalId: 'FriggPrivateSubnet2', physicalId: 'subnet-2', resourceType: 'AWS::EC2::Subnet' },
+                    { logicalId: 'FriggAuroraCluster', physicalId: 'cluster-abc', resourceType: 'AWS::RDS::DBCluster' },
+                    { logicalId: 'FriggKMSKey', physicalId: 'key-xyz', resourceType: 'AWS::KMS::Key' }
+                ],
+                external: [],
+                fromCloudFormation: true,
+                stackName: 'create-frigg-app-production'
+            };
+
+            expect(discovery.fromCloudFormation).toBe(true);
+            expect(discovery.stackManaged).toHaveLength(6);
+
+            // All these resources are in stack - MUST be kept in template
+            expect(isResourceInStack(discovery, 'FriggLambdaSecurityGroup')).toBe(true);
+            expect(isResourceInStack(discovery, 'FriggAuroraCluster')).toBe(true);
+
+            const sg = findStackResource(discovery, 'FriggLambdaSecurityGroup');
+            expect(sg.physicalId).toBe('sg-069629001ade41c9a');
+        });
+
+        it('scenario: use external VPC with stack-managed resources', () => {
+            const discovery = {
+                stackManaged: [
+                    { logicalId: 'FriggLambdaSecurityGroup', physicalId: 'sg-456', resourceType: 'AWS::EC2::SecurityGroup' },
+                    { logicalId: 'FriggPrivateSubnet1', physicalId: 'subnet-1', resourceType: 'AWS::EC2::Subnet' }
+                ],
+                external: [
+                    { physicalId: 'vpc-external', resourceType: 'AWS::EC2::VPC', source: 'user-provided' }
+                ],
+                fromCloudFormation: true,
+                stackName: 'my-app-dev'
+            };
+
+            // VPC is external - should NOT be in template
+            expect(isResourceInStack(discovery, 'FriggVPC')).toBe(false);
+            const externalVpc = findExternalResource(discovery, 'AWS::EC2::VPC');
+            expect(externalVpc.physicalId).toBe('vpc-external');
+
+            // But security group IS in stack - MUST be in template
+            expect(isResourceInStack(discovery, 'FriggLambdaSecurityGroup')).toBe(true);
+        });
+    });
+});

package/infrastructure/domains/shared/types/index.js

@@ -0,0 +1,46 @@
+/**
+ * @fileoverview Central export for all infrastructure types
+ */
+
+const { ResourceOwnership, validateOwnership, resolveOwnership } = require('./resource-ownership');
+
+const {
+    createEmptyDiscoveryResult,
+    findStackResource,
+    findExternalResource,
+    findAllExternalResources,
+    isResourceInStack,
+    getStackLogicalIds
+} = require('./discovery-result');
+
+const {
+    validateAppDefinition,
+    getStackName,
+    isVpcEnabled,
+    isAuroraEnabled,
+    isKmsEnabled,
+    isSsmEnabled
+} = require('./app-definition');
+
+module.exports = {
+    // Resource Ownership
+    ResourceOwnership,
+    validateOwnership,
+    resolveOwnership,
+
+    // Discovery Result
+    createEmptyDiscoveryResult,
+    findStackResource,
+    findExternalResource,
+    findAllExternalResources,
+    isResourceInStack,
+    getStackLogicalIds,
+
+    // App Definition
+    validateAppDefinition,
+    getStackName,
+    isVpcEnabled,
+    isAuroraEnabled,
+    isKmsEnabled,
+    isSsmEnabled
+};

package/infrastructure/domains/shared/types/resource-ownership.js

@@ -0,0 +1,108 @@
+/**
+ * @fileoverview Resource ownership types for clean architecture
+ *
+ * This file defines the core types for the three-layer resource architecture:
+ * 1. Ownership (STACK | EXTERNAL | AUTO)
+ * 2. Discovery (facts about what exists)
+ * 3. Resolution (decisions based on ownership + discovery)
+ */
+
+/**
+ * Resource ownership states
+ * @readonly
+ * @enum {string}
+ */
+const ResourceOwnership = {
+    /**
+     * Resource is managed by our CloudFormation stack
+     * CRITICAL: Must be added to template on every deploy or CloudFormation will delete it
+     */
+    STACK: 'stack',
+
+    /**
+     * Resource exists outside our stack (another stack, manually created, etc.)
+     * Should NOT be added to our template - reference by physical ID only
+     */
+    EXTERNAL: 'external',
+
+    /**
+     * Let the system decide based on discovery results
+     * - If found in our stack → STACK
+     * - If found externally → EXTERNAL
+     * - If not found → STACK (create new)
+     */
+    AUTO: 'auto'
+};
+
+/**
+ * Resource decision made by resolver
+ * @typedef {Object} ResourceDecision
+ * @property {string} ownership - The ownership decision (STACK | EXTERNAL)
+ * @property {string} [physicalId] - Physical resource ID (for EXTERNAL or existing STACK resources)
+ * @property {string[]} [physicalIds] - Multiple physical IDs (e.g., security groups, subnets)
+ * @property {string} reason - Human-readable reason for this decision
+ * @property {Object} [metadata] - Additional metadata about the resource
+ */
+
+/**
+ * Ownership intent from app definition
+ * @typedef {'stack' | 'external' | 'auto'} OwnershipIntent
+ */
+
+/**
+ * Validate ownership value
+ * @param {string} value - Value to validate
+ * @param {string} resourceName - Name of resource for error message
+ * @throws {Error} If value is not valid ownership
+ */
+function validateOwnership(value, resourceName) {
+    const validValues = Object.values(ResourceOwnership);
+    if (!validValues.includes(value)) {
+        throw new Error(
+            `Invalid ownership '${value}' for ${resourceName}. Must be one of: ${validValues.join(', ')}`
+        );
+    }
+}
+
+/**
+ * Resolve final ownership from intent and actual state
+ * @param {OwnershipIntent} intent - User's intent from app definition
+ * @param {boolean} inStack - Whether resource is in our CloudFormation stack
+ * @param {boolean} foundExternal - Whether resource was found externally
+ * @returns {string} Final ownership (STACK | EXTERNAL)
+ */
+function resolveOwnership(intent, inStack, foundExternal) {
+    // Explicit stack
+    if (intent === ResourceOwnership.STACK) {
+        return ResourceOwnership.STACK;
+    }
+
+    // Explicit external
+    if (intent === ResourceOwnership.EXTERNAL) {
+        return ResourceOwnership.EXTERNAL;
+    }
+
+    // Auto-decide
+    if (intent === ResourceOwnership.AUTO) {
+        // CRITICAL: If it's in our stack, it MUST stay in template
+        if (inStack) {
+            return ResourceOwnership.STACK;
+        }
+
+        // Found externally - use it
+        if (foundExternal) {
+            return ResourceOwnership.EXTERNAL;
+        }
+
+        // Not found - create new in stack
+        return ResourceOwnership.STACK;
+    }
+
+    throw new Error(`Invalid ownership intent: ${intent}`);
+}
+
+module.exports = {
+    ResourceOwnership,
+    validateOwnership,
+    resolveOwnership
+};

package/infrastructure/domains/shared/types/resource-ownership.test.js

@@ -0,0 +1,101 @@
+const { ResourceOwnership, validateOwnership, resolveOwnership } = require('./resource-ownership');
+
+describe('ResourceOwnership', () => {
+    describe('enum values', () => {
+        it('should have correct enum values', () => {
+            expect(ResourceOwnership.STACK).toBe('stack');
+            expect(ResourceOwnership.EXTERNAL).toBe('external');
+            expect(ResourceOwnership.AUTO).toBe('auto');
+        });
+    });
+
+    describe('validateOwnership', () => {
+        it('should accept valid ownership values', () => {
+            expect(() => validateOwnership('stack', 'test')).not.toThrow();
+            expect(() => validateOwnership('external', 'test')).not.toThrow();
+            expect(() => validateOwnership('auto', 'test')).not.toThrow();
+        });
+
+        it('should reject invalid ownership values', () => {
+            expect(() => validateOwnership('invalid', 'test')).toThrow(
+                "Invalid ownership 'invalid' for test"
+            );
+            expect(() => validateOwnership('managed', 'test')).toThrow();
+            expect(() => validateOwnership('', 'test')).toThrow();
+        });
+    });
+
+    describe('resolveOwnership', () => {
+        describe('with explicit STACK intent', () => {
+            it('should return STACK regardless of discovery', () => {
+                expect(resolveOwnership('stack', false, false)).toBe('stack');
+                expect(resolveOwnership('stack', true, false)).toBe('stack');
+                expect(resolveOwnership('stack', false, true)).toBe('stack');
+                expect(resolveOwnership('stack', true, true)).toBe('stack');
+            });
+        });
+
+        describe('with explicit EXTERNAL intent', () => {
+            it('should return EXTERNAL regardless of discovery', () => {
+                expect(resolveOwnership('external', false, false)).toBe('external');
+                expect(resolveOwnership('external', true, false)).toBe('external');
+                expect(resolveOwnership('external', false, true)).toBe('external');
+                expect(resolveOwnership('external', true, true)).toBe('external');
+            });
+        });
+
+        describe('with AUTO intent', () => {
+            it('should return STACK if resource is in stack (CRITICAL: must keep in template)', () => {
+                expect(resolveOwnership('auto', true, false)).toBe('stack');
+                expect(resolveOwnership('auto', true, true)).toBe('stack');
+            });
+
+            it('should return EXTERNAL if found externally but not in stack', () => {
+                expect(resolveOwnership('auto', false, true)).toBe('external');
+            });
+
+            it('should return STACK if not found anywhere (will create new)', () => {
+                expect(resolveOwnership('auto', false, false)).toBe('stack');
+            });
+        });
+
+        describe('edge cases', () => {
+            it('should throw on invalid intent', () => {
+                expect(() => resolveOwnership('invalid', false, false)).toThrow(
+                    'Invalid ownership intent: invalid'
+                );
+            });
+
+            it('should handle undefined intent as invalid', () => {
+                expect(() => resolveOwnership(undefined, false, false)).toThrow();
+            });
+        });
+
+        describe('real-world scenarios', () => {
+            it('scenario: fresh deploy, no resources exist', () => {
+                const ownership = resolveOwnership('auto', false, false);
+                expect(ownership).toBe('stack');
+            });
+
+            it('scenario: redeploy existing stack, resource in stack', () => {
+                const ownership = resolveOwnership('auto', true, false);
+                expect(ownership).toBe('stack');
+            });
+
+            it('scenario: resource exists in another stack/manually created', () => {
+                const ownership = resolveOwnership('auto', false, true);
+                expect(ownership).toBe('external');
+            });
+
+            it('scenario: user explicitly wants to use external VPC', () => {
+                const ownership = resolveOwnership('external', false, false);
+                expect(ownership).toBe('external');
+            });
+
+            it('scenario: user explicitly manages in stack even if external exists', () => {
+                const ownership = resolveOwnership('stack', false, true);
+                expect(ownership).toBe('stack');
+            });
+        });
+    });
+});

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@friggframework/devtools",
   "prettier": "@friggframework/prettier-config",
-  "version": "2.0.0--canary.461.8cf93ae.0",
+  "version": "2.0.0--canary.474.aa465e4.0",
   "dependencies": {
     "@aws-sdk/client-ec2": "^3.835.0",
     "@aws-sdk/client-kms": "^3.835.0",
@@ -11,8 +11,8 @@
     "@babel/eslint-parser": "^7.18.9",
     "@babel/parser": "^7.25.3",
     "@babel/traverse": "^7.25.3",
-    "@friggframework/schemas": "2.0.0--canary.461.8cf93ae.0",
-    "@friggframework/test": "2.0.0--canary.461.8cf93ae.0",
+    "@friggframework/schemas": "2.0.0--canary.474.aa465e4.0",
+    "@friggframework/test": "2.0.0--canary.474.aa465e4.0",
     "@hapi/boom": "^10.0.1",
     "@inquirer/prompts": "^5.3.8",
     "axios": "^1.7.2",
@@ -34,8 +34,8 @@
     "serverless-http": "^2.7.0"
   },
   "devDependencies": {
-    "@friggframework/eslint-config": "2.0.0--canary.461.8cf93ae.0",
-    "@friggframework/prettier-config": "2.0.0--canary.461.8cf93ae.0",
+    "@friggframework/eslint-config": "2.0.0--canary.474.aa465e4.0",
+    "@friggframework/prettier-config": "2.0.0--canary.474.aa465e4.0",
     "aws-sdk-client-mock": "^4.1.0",
     "aws-sdk-client-mock-jest": "^4.1.0",
     "jest": "^30.1.3",
@@ -70,5 +70,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "8cf93ae0a6e42ae09247d20d4073495aac4971cf"
+  "gitHead": "aa465e49207b1725bc36827e65efdd54ad879337"
 }