@codeyam/codeyam-cli 0.1.0-staging.28f73cf → 0.1.0-staging.76566f9

package/analyzer-template/packages/analyze/src/lib/files/scenarios/mergeInDependentDataStructure.ts

@@ -1,4 +1,3 @@
-// import { writeFile } from 'node:fs/promises';
 import {
   splitOutsideParenthesesAndArrays,
   joinParenthesesAndArrays,
@@ -22,6 +21,25 @@ function cleanFunctionName(functionName: string) {
   return functionName?.split('<')[0];
 }
 
+// Extract the type parameter from a function name, e.g., 'useFetcher<{ data: UserData }>()' -> '{ data: UserData }'
+function getTypeParameter(functionName: string): string | null {
+  if (!functionName) return null;
+  const openBracket = functionName.indexOf('<');
+  if (openBracket === -1) return null;
+  // Find matching closing bracket, accounting for nested brackets
+  let depth = 0;
+  for (let i = openBracket; i < functionName.length; i++) {
+    if (functionName[i] === '<') depth++;
+    else if (functionName[i] === '>') {
+      depth--;
+      if (depth === 0) {
+        return functionName.slice(openBracket + 1, i);
+      }
+    }
+  }
+  return null;
+}
+
 // Check if schemaPathPart matches or is a function call variant of pathPart
 // e.g., 'isEntityBeingAnalyzed(entity.sha)' matches 'isEntityBeingAnalyzed'
 function pathPartMatches(pathPart: string, schemaPathPart: string): boolean {
@@ -75,47 +93,6 @@ export default function mergeInDependentDataStructure({
     };
   };
 }) {
-  // writeFile(
-  //   'mergeInDependentDataStructure-debug.json',
-  //   JSON.stringify(
-  //     {
-  //       importedExports: importedExports.map((d) => ({
-  //         filePath: d.filePath,
-  //         name: d.name,
-  //         isMocked: d.isMocked,
-  //       })),
-  //       dependentAnalyses: Object.keys(dependentAnalyses).reduce(
-  //         (pathAcc: Record<string, any>, filePath) => {
-  //           pathAcc[filePath] = Object.keys(dependentAnalyses[filePath]).reduce(
-  //             (nameAcc, name) => {
-  //               nameAcc[name] = {
-  //                 metadata: {
-  //                   mergedDataStructure:
-  //                     dependentAnalyses[filePath][name].metadata
-  //                       .mergedDataStructure,
-  //                 },
-  //               };
-  //               return nameAcc;
-  //             },
-  //             {} as { [name: string]: {
-  //               metadata?: {
-  //                 mergedDataStructure?: ReadonlyAnalysis['metadata']['mergedDataStructure'];
-  //               };
-  //             } },
-  //           );
-  //           return pathAcc;
-  //         },
-  //         {},
-  //       ),
-  //       rootScopeName,
-  //       dataStructure,
-  //       dependencySchemas,
-  //     },
-  //     null,
-  //     2,
-  //   ),
-  // ).catch(() => {});
-
   const mergedDataStructure: Omit<
     DataStructure,
     'equivalentSignatureVariables'
@@ -128,6 +105,44 @@ export default function mergeInDependentDataStructure({
     environmentVariables: [...(dataStructure.environmentVariables || [])],
   };
 
+  // Build a set of functions that have multiple DIFFERENT type parameters.
+  // For these functions, we must NOT normalize paths to avoid merging different schemas.
+  // e.g., if we have both useFetcher<{ data: UserData }>() and useFetcher<{ data: ConfigData }>(),
+  // they must stay separate and not both become 'returnValue'.
+  const functionsWithMultipleTypeParams = new Set<string>();
+  const typeParamsByFunction: Record<string, Set<string>> = {};
+
+  // Helper to scan a schema for type parameters
+  const scanSchemaForTypeParams = (schema: { [key: string]: string }) => {
+    for (const schemaPath of Object.keys(schema ?? {})) {
+      const parts = splitOutsideParenthesesAndArrays(schemaPath);
+      if (parts.length > 0) {
+        const firstPart = parts[0];
+        const typeParam = getTypeParameter(firstPart);
+        if (typeParam) {
+          const baseName = cleanFunctionName(firstPart);
+          typeParamsByFunction[baseName] ||= new Set();
+          typeParamsByFunction[baseName].add(typeParam);
+          if (typeParamsByFunction[baseName].size > 1) {
+            functionsWithMultipleTypeParams.add(baseName);
+          }
+        }
+      }
+    }
+  };
+
+  // Scan the root entity's schema
+  scanSchemaForTypeParams(dataStructure.returnValueSchema);
+
+  // Also scan all dependency schemas for type parameters
+  for (const filePath of Object.keys(dependencySchemas ?? {})) {
+    for (const name of Object.keys(dependencySchemas[filePath] ?? {})) {
+      scanSchemaForTypeParams(
+        dependencySchemas[filePath][name]?.returnValueSchema,
+      );
+    }
+  }
+
   let equivalentSchemaPaths: {
     equivalentRoots: {
       schemaRootPath: string;
@@ -186,6 +201,15 @@ export default function mergeInDependentDataStructure({
       const pathParts = splitOutsideParenthesesAndArrays(path);
       if (pathParts.length > 1) {
         if (pathParts[1].startsWith('functionCallReturnValue')) {
+          // Check if this function has multiple DIFFERENT type parameters.
+          // If so, DON'T normalize to returnValue - keep the full path to avoid
+          // merging different type-parameterized variants together.
+          // e.g., useFetcher<{ data: UserData }>().functionCallReturnValue.data
+          // should NOT be merged with useFetcher<{ data: ConfigData }>().functionCallReturnValue.data
+          const baseName = cleanFunctionName(pathParts[0]);
+          if (functionsWithMultipleTypeParams.has(baseName)) {
+            return path; // Keep the original path with type parameters
+          }
           // functionCallReturnValue immediately follows - normalize to returnValue
           // e.g., useAuth().functionCallReturnValue.user -> returnValue.user
           return joinParenthesesAndArrays([
@@ -325,10 +349,14 @@ export default function mergeInDependentDataStructure({
                 splitOutsideParenthesesAndArrays(schemaPath);
 
               if (schemaPathParts[0].startsWith(functionName)) {
-                schemaPathParts =
-                  schemaPathParts[1] === 'functionCallReturnValue'
-                    ? ['returnValue', ...schemaPathParts.slice(2)]
-                    : schemaPathParts.slice(1);
+                // Only normalize if the function doesn't have multiple different type parameters
+                const baseName = cleanFunctionName(schemaPathParts[0]);
+                if (!functionsWithMultipleTypeParams.has(baseName)) {
+                  schemaPathParts =
+                    schemaPathParts[1] === 'functionCallReturnValue'
+                      ? ['returnValue', ...schemaPathParts.slice(2)]
+                      : schemaPathParts.slice(1);
+                }
               }
 
               if (schemaPathParts.length < pathParts.length) continue;
@@ -398,6 +426,7 @@ export default function mergeInDependentDataStructure({
                   const postfix = joinParenthesesAndArrays(
                     schemaPathParts.slice(matchedUpToIndex),
                   );
+
                   entry.equivalentPostfixes[postfix] = entry
                     .equivalentPostfixes[postfix]
                     ? bestValueFromOptions([
@@ -480,6 +509,47 @@ export default function mergeInDependentDataStructure({
   const mergeAllEquivalentSchemaPaths = () => {
     const mergedEquivalentSchemaPaths: typeof equivalentSchemaPaths = [];
 
+    // Pre-pass: Connect entries with array/array-element relationships.
+    // This handles cases like:
+    // - Entry A has root 'surveys' (array)
+    // - Entry B has root 'surveys[]' (array element)
+    // These need to be connected so Entry B's field postfixes flow to Entry A.
+    // We do this before the main merge to ensure the connection happens regardless
+    // of processing order.
+    for (const esp of equivalentSchemaPaths) {
+      for (const root of esp.equivalentRoots) {
+        if (root.schemaRootPath.endsWith('[]')) {
+          // Find a matching parent entry with the base array path
+          const baseArrayPath = root.schemaRootPath.slice(0, -2);
+          const parentEntry = equivalentSchemaPaths.find(
+            (other) =>
+              other !== esp &&
+              other.equivalentRoots.some(
+                (otherRoot) =>
+                  otherRoot.schemaRootPath === baseArrayPath &&
+                  otherRoot.function?.name === root.function?.name &&
+                  otherRoot.function?.filePath === root.function?.filePath,
+              ),
+          );
+          if (parentEntry) {
+            // Add transformed postfixes from child (array element) to parent (array)
+            // so they can be applied with [] prefix to parent paths
+            for (const [postfixPath, postfixValue] of Object.entries(
+              esp.equivalentPostfixes,
+            )) {
+              const transformedPostfix = joinParenthesesAndArrays(
+                ['[]', postfixPath].filter(Boolean),
+              );
+              if (!(transformedPostfix in parentEntry.equivalentPostfixes)) {
+                parentEntry.equivalentPostfixes[transformedPostfix] =
+                  postfixValue;
+              }
+            }
+          }
+        }
+      }
+    }
+
     const findEquivalentSchemaPathEntry = (
       schemaSubPath: string,
       equivalentRootFunction: (typeof equivalentSchemaPaths)[0]['equivalentRoots'][0]['function'],
@@ -673,6 +743,7 @@ export default function mergeInDependentDataStructure({
           equivalentRoot.schemaRootPath,
           relevantPostfix,
         ]);
+
         schema[newSchemaPath] = postfixValue;
       }
 
@@ -680,6 +751,77 @@ export default function mergeInDependentDataStructure({
     }
   }
 
+  // Propagate equivalency-derived attributes to generic function call variants.
+  // When attributes are traced via equivalencies (e.g., fileComparisons from buildDataMap.signature[2]),
+  // they get written to non-generic paths (returnValue.data.x or funcName().functionCallReturnValue.data.x).
+  // If the ORIGINAL input schema has generic variants (funcName<T>().functionCallReturnValue.data),
+  // we need to copy the attributes to those paths too.
+  for (const filePath in mergedDataStructure.dependencySchemas) {
+    for (const depName in mergedDataStructure.dependencySchemas[filePath]) {
+      const depSchema =
+        mergedDataStructure.dependencySchemas[filePath][depName];
+      const returnValueSchema = depSchema.returnValueSchema;
+
+      // Look at the ORIGINAL input dependencySchemas for generic variants,
+      // since the merged schema may have lost them during equivalency processing
+      const originalSchema = dependencySchemas?.[filePath]?.[depName];
+      const schemaToSearchForGenericVariants =
+        originalSchema?.returnValueSchema || returnValueSchema;
+
+      // Find all unique generic variants of this function
+      // e.g., useFetcher<BranchEntityDiffResult>() from useFetcher<BranchEntityDiffResult>().functionCallReturnValue.data
+      const genericVariants = new Set<string>();
+      const genericRegex = new RegExp(
+        `^${depName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}<[^>]+>\\(\\)`,
+      );
+
+      for (const path in schemaToSearchForGenericVariants) {
+        const match = path.match(genericRegex);
+        if (match) {
+          genericVariants.add(match[0]);
+        }
+      }
+
+      if (genericVariants.size === 0) continue;
+
+      // For each returnValue. path or non-generic function call path,
+      // create corresponding paths for each generic variant
+      const pathsToAdd: [string, string][] = [];
+
+      for (const path in returnValueSchema) {
+        const value = returnValueSchema[path];
+
+        // Handle returnValue. paths
+        if (path.startsWith('returnValue.')) {
+          const suffix = path.slice('returnValue.'.length);
+          for (const genericVariant of genericVariants) {
+            const genericPath = `${genericVariant}.functionCallReturnValue.${suffix}`;
+            if (!(genericPath in returnValueSchema)) {
+              pathsToAdd.push([genericPath, value]);
+            }
+          }
+        }
+        // Handle non-generic function call paths like depName().functionCallReturnValue.x
+        else if (path.startsWith(`${depName}().functionCallReturnValue.`)) {
+          const suffix = path.slice(
+            `${depName}().functionCallReturnValue.`.length,
+          );
+          for (const genericVariant of genericVariants) {
+            const genericPath = `${genericVariant}.functionCallReturnValue.${suffix}`;
+            if (!(genericPath in returnValueSchema)) {
+              pathsToAdd.push([genericPath, value]);
+            }
+          }
+        }
+      }
+
+      // Add the new generic variant paths
+      for (const [path, value] of pathsToAdd) {
+        returnValueSchema[path] = value;
+      }
+    }
+  }
+
   // For mocked dependencies: copy paths from dependencySchemas (usage info) and normalize
   // returnValue. paths that were created by equivalency processing.
   // This ensures all paths use the consistent functionName().functionCallReturnValue. format.
@@ -695,33 +837,38 @@ export default function mergeInDependentDataStructure({
       name: dependency.name,
     });
 
-    // First, normalize any returnValue. paths that were written by equivalency processing
-    // to the standard functionName().functionCallReturnValue. format.
-    // Also delete returnValue[] artifact paths that don't represent actual array structure.
+    // First, normalize any returnValue paths that were written by equivalency processing
+    // to the standard functionName().functionCallReturnValue format.
+    // This includes both returnValue. (dot) and returnValue[ (array) paths.
     const pathsToNormalize: [string, string][] = [];
-    const pathsToDelete: string[] = [];
     for (const path in depSchema.returnValueSchema) {
-      if (path === 'returnValue' || path.startsWith('returnValue.')) {
+      if (
+        path === 'returnValue' ||
+        path.startsWith('returnValue.') ||
+        path.startsWith('returnValue[')
+      ) {
         pathsToNormalize.push([path, depSchema.returnValueSchema[path]]);
-      } else if (path.match(/^returnValue\[\d*\]/)) {
-        // Delete returnValue[] and returnValue[n] paths - these are artifacts from
-        // equivalency processing and don't represent the actual structure of mocked dependencies.
-        // The correct structure comes from srcSchema (dependencySchemas).
-        pathsToDelete.push(path);
       }
     }
-    for (const path of pathsToDelete) {
-      delete depSchema.returnValueSchema[path];
-    }
     for (const [path, value] of pathsToNormalize) {
       delete depSchema.returnValueSchema[path];
-      const normalizedPath =
-        path === 'returnValue'
-          ? `${dependency.name}().functionCallReturnValue`
-          : path.replace(
-              /^returnValue\./,
-              `${dependency.name}().functionCallReturnValue.`,
-            );
+      let normalizedPath: string;
+      if (path === 'returnValue') {
+        normalizedPath = `${dependency.name}().functionCallReturnValue`;
+      } else if (path.startsWith('returnValue.')) {
+        normalizedPath = path.replace(
+          /^returnValue\./,
+          `${dependency.name}().functionCallReturnValue.`,
+        );
+      } else {
+        // path.startsWith('returnValue[')
+        // e.g., returnValue[] -> getOptions().functionCallReturnValue[]
+        // e.g., returnValue[].label -> getOptions().functionCallReturnValue[].label
+        normalizedPath = path.replace(
+          /^returnValue/,
+          `${dependency.name}().functionCallReturnValue`,
+        );
+      }
       depSchema.returnValueSchema[normalizedPath] = value;
     }
 
@@ -773,11 +920,123 @@ export default function mergeInDependentDataStructure({
           depSchema.returnValueSchema[path] = value;
         }
       }
+
+      // Copy object-typed paths for chained API access patterns (like trpc.customer.getCustomersByOrg)
+      // These intermediate paths are needed for constructMockCode to build the nested mock structure.
+      // Example: for trpc.customer.getCustomersByOrg.useQuery().functionCallReturnValue.data,
+      // we need 'trpc', 'trpc.customer', 'trpc.customer.getCustomersByOrg' all typed as 'object'.
+      // Skip paths starting with 'returnValue' - they were already handled above
+      //
+      // EXCEPTION: For function-style dependencies like getSupabase(), skip intermediate object
+      // paths like 'getSupabase().auth' that are just property access after a function call.
+      // These aren't needed because constructMockCode can infer the structure from the actual
+      // function call paths like 'getSupabase().auth.getUser()'. We only need object paths
+      // for object-style dependencies like 'supabase.auth' where the dependency itself is an object.
+      if (value === 'object' && !path.startsWith('returnValue')) {
+        // Check if this is a function-style dependency (path starts with name() or name<T>())
+        const isFunctionStyleDependency =
+          path.startsWith(`${dependency.name}()`) ||
+          path.match(new RegExp(`^${dependency.name}<[^>]+>\\(\\)`));
+
+        // For function-style dependencies, skip intermediate object paths
+        // Only keep object paths that are within functionCallReturnValue
+        if (
+          isFunctionStyleDependency &&
+          !path.includes('.functionCallReturnValue')
+        ) {
+          continue;
+        }
+
+        if (!(path in depSchema.returnValueSchema)) {
+          depSchema.returnValueSchema[path] = value;
+        }
+      }
     }
 
     cleanSchema(depSchema.returnValueSchema);
   }
 
+  // Process the input dependencySchemas FIRST (before child dependentAnalyses).
+  // This ensures the parent entity's direct usage of dependencies takes precedence.
+  // When both parent and child use the same dependency (e.g., useLoaderData),
+  // the parent's schema paths are preserved, and child's paths are merged in later.
+  //
+  // Some dependencies (like .d.ts type declaration files) may not have:
+  // - Equivalencies with the root scope
+  // - A dependent analysis (they're just type declarations)
+  // - Be marked as mocked
+  // Without this, their schemas would be lost entirely.
+  for (const filePath in dependencySchemas) {
+    for (const name in dependencySchemas[filePath]) {
+      const srcSchema = dependencySchemas[filePath][name];
+      if (!srcSchema) continue;
+
+      // Skip mocked dependencies - they were already processed above with path normalization
+      if (mockedDependencies.has(`${filePath}::${name}`)) {
+        continue;
+      }
+
+      // Check if this dependency was already processed by equivalencies
+      const existingSchema =
+        mergedDataStructure.dependencySchemas[filePath]?.[name];
+
+      // Only add if no existing schema (equivalencies didn't process it)
+      if (!existingSchema) {
+        const depSchema = findOrCreateDependentSchemas({ filePath, name });
+        for (const path in srcSchema.returnValueSchema) {
+          depSchema.returnValueSchema[path] = srcSchema.returnValueSchema[path];
+        }
+        for (const path in srcSchema.signatureSchema) {
+          depSchema.signatureSchema[path] = srcSchema.signatureSchema[path];
+        }
+
+        // Clean known object functions (like String.prototype.replace, Array.prototype.map)
+        // from the copied schema. Without this, method call paths on primitives like
+        // "projectSlug.replace(...)" would cause convertDotNotation to create nested
+        // object structures instead of preserving the primitive type.
+        cleanSchema(depSchema.returnValueSchema);
+      }
+
+      // For functions with multiple different type parameters, also create separate entries
+      // for each type-parameterized variant. This allows gatherDataForMocks to look up
+      // the specific schema for each call signature.
+      // This runs regardless of whether the base entry already existed, since we need
+      // the separate variant entries for proper schema lookup.
+      const baseName = cleanFunctionName(name);
+      if (functionsWithMultipleTypeParams.has(baseName)) {
+        // Find all unique type-parameterized call signatures in the schema
+        const typeParamVariants = new Set<string>();
+        for (const path of Object.keys(srcSchema.returnValueSchema)) {
+          const parts = splitOutsideParenthesesAndArrays(path);
+          if (
+            parts.length > 0 &&
+            parts[0].includes('<') &&
+            parts[0].endsWith(')')
+          ) {
+            typeParamVariants.add(parts[0]);
+          }
+        }
+
+        // Create a separate entry for each type-parameterized variant
+        for (const variant of typeParamVariants) {
+          const variantSchema = findOrCreateDependentSchemas({
+            filePath,
+            name: variant,
+          });
+
+          // Copy only paths that belong to this variant
+          for (const path in srcSchema.returnValueSchema) {
+            if (path.startsWith(variant)) {
+              variantSchema.returnValueSchema[path] =
+                srcSchema.returnValueSchema[path];
+            }
+          }
+          cleanSchema(variantSchema.returnValueSchema);
+        }
+      }
+    }
+  }
+
   // Ensure ALL dependencies from dependentAnalyses are included in dependencySchemas,
   // even if they have no equivalencies with the root scope.
   // This preserves nested functionCallReturnValue paths that would otherwise be lost.
@@ -853,11 +1112,5 @@ export default function mergeInDependentDataStructure({
     }
   }
 
-  // writeFile(
-  //   'mergeInDependentDataStructure-debug-result.json',
-  //   // rootScopeName,
-  //   JSON.stringify(mergedDataStructure, null, 2),
-  // ).catch(() => {});
-
   return mergedDataStructure;
 }

package/analyzer-template/packages/analyze/src/lib/files/scenarios/mergeValidatedDataStructures.ts

@@ -176,9 +176,19 @@ export default function mergeValidatedDataStructures({
       }
     }
 
-    for (const mockName in dependentAnalysis?.metadata?.scenariosDataStructure
-      ?.dataForMocks ?? {}) {
+    const dependencyDataForMocks =
+      dependentAnalysis?.metadata?.scenariosDataStructure?.dataForMocks ?? {};
+    for (const mockName in dependencyDataForMocks) {
       addMockDataForEntity(mockName);
+
+      // If addMockDataForEntity didn't find matching entries in validatedVariables,
+      // copy the dependency's value directly. This handles cases like usePathname()
+      // which returns a simple "string" type but isn't in the root's validatedVariables.
+      if (dataForMocks[mockName] === undefined) {
+        dataForMocks[mockName] = dependencyDataForMocks[
+          mockName
+        ] as JsonTypeDefinition;
+      }
     }
   }
 

package/analyzer-template/packages/analyze/src/lib/files/setImportedExports.ts

@@ -3,7 +3,7 @@ import { ProjectAnalyzer } from '../ProjectAnalyzer';
 import getImportedExports from './getImportedExports';
 import { getFrameworkForFile, isFrameworkRoute } from '~codeyam/utils';
 import findOrCreateEntity from './analyze/findOrCreateEntity';
-import { generateSha, loadEntities, upsertEntities } from '~codeyam/supabase';
+import { generateSha, loadEntities, upsertEntities } from '~codeyam/database';
 import { AnalysisContext } from '../analysisContext';
 import analyzeFrameworkRoute from './analyzeFrameworkRoute';
 

package/analyzer-template/packages/aws/dist/src/lib/s3/checkS3ObjectExists.d.ts

@@ -0,0 +1,15 @@
+interface CheckS3ObjectExistsArgs {
+    bucketName: string;
+    key: string;
+}
+interface CheckS3ObjectExistsResult {
+    exists: boolean;
+    size?: number;
+}
+/**
+ * Check if an object exists in S3 using a HEAD request.
+ * Returns the object size if it exists.
+ */
+export default function checkS3ObjectExists({ bucketName, key, }: CheckS3ObjectExistsArgs): Promise<CheckS3ObjectExistsResult>;
+export {};
+//# sourceMappingURL=checkS3ObjectExists.d.ts.map

package/analyzer-template/packages/aws/dist/src/lib/s3/checkS3ObjectExists.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"checkS3ObjectExists.d.ts","sourceRoot":"","sources":["../../../../src/lib/s3/checkS3ObjectExists.ts"],"names":[],"mappings":"AAEA,UAAU,uBAAuB;IAC/B,UAAU,EAAE,MAAM,CAAC;IACnB,GAAG,EAAE,MAAM,CAAC;CACb;AAED,UAAU,yBAAyB;IACjC,MAAM,EAAE,OAAO,CAAC;IAChB,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED;;;GAGG;AACH,wBAA8B,mBAAmB,CAAC,EAChD,UAAU,EACV,GAAG,GACJ,EAAE,uBAAuB,GAAG,OAAO,CAAC,yBAAyB,CAAC,CA2B9D"}

package/analyzer-template/packages/aws/dist/src/lib/s3/checkS3ObjectExists.js

@@ -0,0 +1,31 @@
+import { S3Client, HeadObjectCommand } from '@aws-sdk/client-s3';
+/**
+ * Check if an object exists in S3 using a HEAD request.
+ * Returns the object size if it exists.
+ */
+export default async function checkS3ObjectExists({ bucketName, key, }) {
+    const s3Client = new S3Client({});
+    const command = new HeadObjectCommand({
+        Bucket: bucketName,
+        Key: key,
+    });
+    try {
+        const response = await s3Client.send(command);
+        return {
+            exists: true,
+            size: response.ContentLength,
+        };
+    }
+    catch (error) {
+        // NotFound is expected when object doesn't exist
+        if (error &&
+            typeof error === 'object' &&
+            'name' in error &&
+            error.name === 'NotFound') {
+            return { exists: false };
+        }
+        // Re-throw unexpected errors
+        throw error;
+    }
+}
+//# sourceMappingURL=checkS3ObjectExists.js.map

package/analyzer-template/packages/aws/dist/src/lib/s3/checkS3ObjectExists.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"checkS3ObjectExists.js","sourceRoot":"","sources":["../../../../src/lib/s3/checkS3ObjectExists.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AAYjE;;;GAGG;AACH,MAAM,CAAC,OAAO,CAAC,KAAK,UAAU,mBAAmB,CAAC,EAChD,UAAU,EACV,GAAG,GACqB;IACxB,MAAM,QAAQ,GAAG,IAAI,QAAQ,CAAC,EAAE,CAAC,CAAC;IAElC,MAAM,OAAO,GAAG,IAAI,iBAAiB,CAAC;QACpC,MAAM,EAAE,UAAU;QAClB,GAAG,EAAE,GAAG;KACT,CAAC,CAAC;IAEH,IAAI,CAAC;QACH,MAAM,QAAQ,GAAG,MAAM,QAAQ,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QAC9C,OAAO;YACL,MAAM,EAAE,IAAI;YACZ,IAAI,EAAE,QAAQ,CAAC,aAAa;SAC7B,CAAC;IACJ,CAAC;IAAC,OAAO,KAAc,EAAE,CAAC;QACxB,iDAAiD;QACjD,IACE,KAAK;YACL,OAAO,KAAK,KAAK,QAAQ;YACzB,MAAM,IAAI,KAAK;YACf,KAAK,CAAC,IAAI,KAAK,UAAU,EACzB,CAAC;YACD,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC;QAC3B,CAAC;QACD,6BAA6B;QAC7B,MAAM,KAAK,CAAC;IACd,CAAC;AACH,CAAC"}

package/analyzer-template/packages/aws/dist/src/lib/s3/getPresignedUrl.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getPresignedUrl.d.ts","sourceRoot":"","sources":["../../../../src/lib/s3/getPresignedUrl.ts"],"names":[],"mappings":"AAOA,UAAU,yBAAyB;IACjC,UAAU,EAAE,MAAM,CAAC;IACnB,GAAG,EAAE,MAAM,CAAC;IACZ,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B;AAED,UAAU,2BAA2B;IACnC,UAAU,EAAE,MAAM,CAAC;IACnB,GAAG,EAAE,MAAM,CAAC;IACZ,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B;AAKD;;;GAGG;AACH,wBAAsB,qBAAqB,CAAC,EAC1C,UAAU,EACV,GAAG,EACH,WAAgC,EAChC,gBAAwC,GACzC,EAAE,yBAAyB,GAAG,OAAO,CAAC,MAAM,CAAC,CAU7C;AAED;;;GAGG;AACH,wBAAsB,uBAAuB,CAAC,EAC5C,UAAU,EACV,GAAG,EACH,gBAA0C,GAC3C,EAAE,2BAA2B,GAAG,OAAO,CAAC,MAAM,CAAC,CAS/C"}
+{"version":3,"file":"getPresignedUrl.d.ts","sourceRoot":"","sources":["../../../../src/lib/s3/getPresignedUrl.ts"],"names":[],"mappings":"AAOA,UAAU,yBAAyB;IACjC,UAAU,EAAE,MAAM,CAAC;IACnB,GAAG,EAAE,MAAM,CAAC;IACZ,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B;AAED,UAAU,2BAA2B;IACnC,UAAU,EAAE,MAAM,CAAC;IACnB,GAAG,EAAE,MAAM,CAAC;IACZ,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B;AAKD;;;GAGG;AACH,wBAAgB,qBAAqB,CAAC,EACpC,UAAU,EACV,GAAG,EACH,WAAgC,EAChC,gBAAwC,GACzC,EAAE,yBAAyB,GAAG,OAAO,CAAC,MAAM,CAAC,CAU7C;AAED;;;GAGG;AACH,wBAAgB,uBAAuB,CAAC,EACtC,UAAU,EACV,GAAG,EACH,gBAA0C,GAC3C,EAAE,2BAA2B,GAAG,OAAO,CAAC,MAAM,CAAC,CAS/C"}

package/analyzer-template/packages/aws/dist/src/lib/s3/getPresignedUrl.js

@@ -6,7 +6,7 @@ const DEFAULT_DOWNLOAD_EXPIRY = 24 * 60 * 60; // 24 hours
  * Generate a presigned URL for uploading a file to S3.
  * The client can PUT directly to this URL without AWS credentials.
  */
-export async function getPresignedUploadUrl({ bucketName, key, contentType = 'application/gzip', expiresInSeconds = DEFAULT_UPLOAD_EXPIRY, }) {
+export function getPresignedUploadUrl({ bucketName, key, contentType = 'application/gzip', expiresInSeconds = DEFAULT_UPLOAD_EXPIRY, }) {
     const s3Client = new S3Client({});
     const command = new PutObjectCommand({
         Bucket: bucketName,
@@ -19,7 +19,7 @@ export async function getPresignedUploadUrl({ bucketName, key, contentType = 'ap
  * Generate a presigned URL for downloading a file from S3.
  * Anyone with this URL can GET the file without AWS credentials.
  */
-export async function getPresignedDownloadUrl({ bucketName, key, expiresInSeconds = DEFAULT_DOWNLOAD_EXPIRY, }) {
+export function getPresignedDownloadUrl({ bucketName, key, expiresInSeconds = DEFAULT_DOWNLOAD_EXPIRY, }) {
     const s3Client = new S3Client({});
     const command = new GetObjectCommand({
         Bucket: bucketName,

package/analyzer-template/packages/aws/dist/src/lib/s3/getPresignedUrl.js.map

@@ -1 +1 @@
-{"version":3,"file":"getPresignedUrl.js","sourceRoot":"","sources":["../../../../src/lib/s3/getPresignedUrl.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EACR,gBAAgB,EAChB,gBAAgB,GACjB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAAE,YAAY,EAAE,MAAM,+BAA+B,CAAC;AAe7D,MAAM,qBAAqB,GAAG,CAAC,GAAG,EAAE,GAAG,EAAE,CAAC,CAAC,UAAU;AACrD,MAAM,uBAAuB,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,CAAC,CAAC,WAAW;AAEzD;;;GAGG;AACH,MAAM,CAAC,KAAK,UAAU,qBAAqB,CAAC,EAC1C,UAAU,EACV,GAAG,EACH,WAAW,GAAG,kBAAkB,EAChC,gBAAgB,GAAG,qBAAqB,GACd;IAC1B,MAAM,QAAQ,GAAG,IAAI,QAAQ,CAAC,EAAE,CAAC,CAAC;IAElC,MAAM,OAAO,GAAG,IAAI,gBAAgB,CAAC;QACnC,MAAM,EAAE,UAAU;QAClB,GAAG,EAAE,GAAG;QACR,WAAW,EAAE,WAAW;KACzB,CAAC,CAAC;IAEH,OAAO,YAAY,CAAC,QAAQ,EAAE,OAAO,EAAE,EAAE,SAAS,EAAE,gBAAgB,EAAE,CAAC,CAAC;AAC1E,CAAC;AAED;;;GAGG;AACH,MAAM,CAAC,KAAK,UAAU,uBAAuB,CAAC,EAC5C,UAAU,EACV,GAAG,EACH,gBAAgB,GAAG,uBAAuB,GACd;IAC5B,MAAM,QAAQ,GAAG,IAAI,QAAQ,CAAC,EAAE,CAAC,CAAC;IAElC,MAAM,OAAO,GAAG,IAAI,gBAAgB,CAAC;QACnC,MAAM,EAAE,UAAU;QAClB,GAAG,EAAE,GAAG;KACT,CAAC,CAAC;IAEH,OAAO,YAAY,CAAC,QAAQ,EAAE,OAAO,EAAE,EAAE,SAAS,EAAE,gBAAgB,EAAE,CAAC,CAAC;AAC1E,CAAC"}
+{"version":3,"file":"getPresignedUrl.js","sourceRoot":"","sources":["../../../../src/lib/s3/getPresignedUrl.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EACR,gBAAgB,EAChB,gBAAgB,GACjB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAAE,YAAY,EAAE,MAAM,+BAA+B,CAAC;AAe7D,MAAM,qBAAqB,GAAG,CAAC,GAAG,EAAE,GAAG,EAAE,CAAC,CAAC,UAAU;AACrD,MAAM,uBAAuB,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,CAAC,CAAC,WAAW;AAEzD;;;GAGG;AACH,MAAM,UAAU,qBAAqB,CAAC,EACpC,UAAU,EACV,GAAG,EACH,WAAW,GAAG,kBAAkB,EAChC,gBAAgB,GAAG,qBAAqB,GACd;IAC1B,MAAM,QAAQ,GAAG,IAAI,QAAQ,CAAC,EAAE,CAAC,CAAC;IAElC,MAAM,OAAO,GAAG,IAAI,gBAAgB,CAAC;QACnC,MAAM,EAAE,UAAU;QAClB,GAAG,EAAE,GAAG;QACR,WAAW,EAAE,WAAW;KACzB,CAAC,CAAC;IAEH,OAAO,YAAY,CAAC,QAAQ,EAAE,OAAO,EAAE,EAAE,SAAS,EAAE,gBAAgB,EAAE,CAAC,CAAC;AAC1E,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,uBAAuB,CAAC,EACtC,UAAU,EACV,GAAG,EACH,gBAAgB,GAAG,uBAAuB,GACd;IAC5B,MAAM,QAAQ,GAAG,IAAI,QAAQ,CAAC,EAAE,CAAC,CAAC;IAElC,MAAM,OAAO,GAAG,IAAI,gBAAgB,CAAC;QACnC,MAAM,EAAE,UAAU;QAClB,GAAG,EAAE,GAAG;KACT,CAAC,CAAC;IAEH,OAAO,YAAY,CAAC,QAAQ,EAAE,OAAO,EAAE,EAAE,SAAS,EAAE,gBAAgB,EAAE,CAAC,CAAC;AAC1E,CAAC"}

package/analyzer-template/packages/aws/package.json

@@ -12,12 +12,12 @@
   "license": "ISC",
   "dependencies": {
     "@aws-sdk/client-codebuild": "^3.948.0",
-    "@aws-sdk/client-cloudwatch-logs": "^3.940.0",
-    "@aws-sdk/client-dynamodb": "^3.899.0",
+    "@aws-sdk/client-cloudwatch-logs": "^3.962.0",
+    "@aws-sdk/client-dynamodb": "^3.956.0",
     "@aws-sdk/client-ecr": "^3.948.0",
-    "@aws-sdk/client-ecs": "^3.937.0",
+    "@aws-sdk/client-ecs": "^3.956.0",
     "@aws-sdk/client-s3": "^3.940.0",
-    "@aws-sdk/client-sqs": "^3.940.0",
+    "@aws-sdk/client-sqs": "^3.956.0",
     "@aws-sdk/lib-storage": "^3.940.0",
     "@aws-sdk/s3-request-presigner": "^3.940.0",
     "@aws-sdk/util-dynamodb": "^3.902.0"

package/analyzer-template/packages/aws/s3/index.ts

@@ -4,3 +4,4 @@ export {
   getPresignedUploadUrl,
   getPresignedDownloadUrl,
 } from '../src/lib/s3/getPresignedUrl';
+export { default as checkS3ObjectExists } from '../src/lib/s3/checkS3ObjectExists';