update error handling for js resolvers input path validations (#2782)

Author: Amplifiyer

.changeset/five-dancers-brush.md

@@ -0,0 +1,5 @@
+---
+'@aws-amplify/backend-data': patch
+---
+
+Update error handling for js resolvers input path validations

packages/backend-data/src/resolve_entry_path.test.ts

@@ -0,0 +1,24 @@
+import { beforeEach, describe, it, mock } from 'node:test';
+import assert from 'node:assert';
+import { resolveEntryPath } from './resolve_entry_path.js';
+import fs from 'fs';
+void describe('resolveEntryPath', () => {
+  const testExistentPath = '/existent/path';
+  const fsMock = mock.method(fs, 'existsSync', (path: string) => {
+    if (path === testExistentPath) return true;
+    return false;
+  });
+  void beforeEach(() => {
+    fsMock.mock.resetCalls();
+  });
+  void it('should return the same path if it is a string and it exists', () => {
+    const result = resolveEntryPath(testExistentPath);
+    assert.strictEqual(result, testExistentPath);
+  });
+
+  void it('should throw error if the path is a string and it does not exist', () => {
+    assert.throws(() => resolveEntryPath('testNonExistentPath'), {
+      message: 'Cannot find file at testNonExistentPath',
+    });
+  });
+});

packages/backend-data/src/resolve_entry_path.ts

@@ -5,31 +5,37 @@ import {
 import { dirname, join } from 'path';
 import type { JsResolverEntry } from '@aws-amplify/data-schema-types';
 import { AmplifyDataError } from './types.js';
+import fs from 'fs';
 
 /**
  * Resolve JS Resolver Handler or Sql Reference Handler entry path to absolute path
  * @param entry handler entry
  * @returns resolved absolute file path
  */
 export const resolveEntryPath = (entry: JsResolverEntry): string => {
-  const unresolvedImportLocationError = new AmplifyUserError<AmplifyDataError>(
-    'UnresolvedEntryPathError',
-    {
-      message:
-        'Could not determine import path to construct absolute code path from relative path: ' +
-        JSON.stringify(entry),
-      resolution: 'Consider using an absolute path instead.',
-    },
-  );
-
   if (typeof entry === 'string') {
-    return entry;
+    if (fs.existsSync(entry)) {
+      return entry;
+    }
+    throw new AmplifyUserError<AmplifyDataError>('InvalidPathError', {
+      message: `Cannot find file at ${entry}`,
+      resolution: `Check that the file exists at ${entry} and is readable`,
+    });
   }
 
-  const filePath = new FilePathExtractor(entry.importLine).extract();
-  if (filePath) {
-    return join(dirname(filePath), entry.relativePath);
+  const importPath = new FilePathExtractor(entry.importLine).extract();
+
+  if (importPath) {
+    const filePath = join(dirname(importPath), entry.relativePath);
+    if (filePath && fs.existsSync(filePath)) {
+      return filePath;
+    }
   }
 
-  throw unresolvedImportLocationError;
+  throw new AmplifyUserError<AmplifyDataError>('UnresolvedEntryPathError', {
+    message:
+      'Could not determine import path to construct absolute code path from relative path: ' +
+      JSON.stringify(entry),
+    resolution: 'Consider using an absolute path instead.',
+  });
 };

packages/backend-data/src/types.ts

@@ -159,6 +159,7 @@ export type DataProps = {
 
 export type AmplifyDataError =
   | 'DefineDataConfigurationError'
+  | 'InvalidPathError'
   | 'InvalidSchemaAuthError'
   | 'InvalidSchemaError'
   | 'MultipleSingletonResourcesError'