@sylvesterllc/aws-constructs 1.1.26 → 1.1.29

package/src/resources/lambda/create-basic-lambda.ts

@@ -1,279 +1,161 @@
-import { Duration } from "aws-cdk-lib";
-import { ServicePrincipal } from "aws-cdk-lib/aws-iam";
-import { LayerVersion, Runtime } from "aws-cdk-lib/aws-lambda";
-import {
-  NodejsFunction,
-  NodejsFunctionProps,
-  SourceMapMode,
-} from "aws-cdk-lib/aws-lambda-nodejs";
-import { RetentionDays } from "aws-cdk-lib/aws-logs";
-import fs = require("fs");
-import path = require("path");
-import { TimerJobProps } from "../../interfaces/timer-job";
-import { Construct } from "constructs";
-import { SERVICE_PRINCIPAL } from "../../constants/aws-service-principal-constants";
-import { CronOptions, Rule, Schedule } from "aws-cdk-lib/aws-events";
-import { LambdaFunction } from "aws-cdk-lib/aws-events-targets";
-import { Table } from "aws-cdk-lib/aws-dynamodb";
-
-const isSubPath = (root: string, target: string): boolean => {
-  const relative = path.relative(path.resolve(root), path.resolve(target));
-  return relative === "" || (!relative.startsWith("..") && !path.isAbsolute(relative));
-};
-
-const LOCK_FILE_NAMES = ["pnpm-lock.yaml", "yarn.lock", "package-lock.json"];
-
-const resolveProjectRoot = (projectRoot?: string): string | undefined => {
-  if (!projectRoot) {
-    return undefined;
-  }
-
-  return path.isAbsolute(projectRoot)
-    ? path.resolve(projectRoot)
-    : path.resolve(process.cwd(), projectRoot);
-};
-
-const findNearestLockFile = (startDir: string): string | undefined => {
-  let current = path.resolve(startDir);
-  const { root } = path.parse(current);
-
-  while (true) {
-    for (const candidate of LOCK_FILE_NAMES) {
-      const resolvedCandidate = path.join(current, candidate);
-      if (fs.existsSync(resolvedCandidate) && fs.statSync(resolvedCandidate).isFile()) {
-        return resolvedCandidate;
-      }
-    }
-
-    if (current === root) {
-      return undefined;
-    }
-
-    current = path.dirname(current);
-  }
-};
-
-const findCommonAncestor = (paths: string[]): string | undefined => {
-  if (paths.length === 0) {
-    return undefined;
-  }
-
-  let ancestor = path.resolve(paths[0]);
-
-  for (const currentPath of paths.slice(1)) {
-    const target = path.resolve(currentPath);
-    const ancestorRoot = path.parse(ancestor).root;
-
-    if (path.parse(ancestor).root.toLowerCase() !== path.parse(target).root.toLowerCase()) {
-      return undefined;
-    }
-
-    let candidate = ancestor;
-    while (!isSubPath(candidate, target)) {
-      if (candidate === ancestorRoot) {
-        candidate = ancestorRoot;
-        break;
-      }
-      candidate = path.dirname(candidate);
-    }
-
-    ancestor = candidate;
-  }
-
-  return ancestor;
-};
-
-const resolvePath = (inputPath: string, projectRoot?: string): string => {
-  if (path.isAbsolute(inputPath)) {
-    return path.resolve(inputPath);
-  }
-
-  if (projectRoot) {
-    const candidateFromProjectRoot = path.resolve(projectRoot, inputPath);
-    if (isSubPath(projectRoot, candidateFromProjectRoot)) {
-      return candidateFromProjectRoot;
-    }
-  }
-
-  return path.resolve(process.cwd(), inputPath);
-};
-
-export const createBasicLambdaTimerJob = (
-  scope: Construct,
-  props: TimerJobProps
-): NodejsFunction => {
-  const lambdaProps = createBasicLambdaProps(props);
-
-  let lambdaFunction = new NodejsFunction(
-    scope,
-    `${props.appPrefix}${props.functionName}`,
-    lambdaProps
-  );
-
-  addInvokePermissionToLambdaForEvents(lambdaFunction);
-
-  const eventRule = createEventRuleForLambda(
-    scope,
-    lambdaFunction,
-    props.cronOptions
-  );
-
-  eventRule.addTarget(new LambdaFunction(lambdaFunction));
-
-  grantAccessToDynamoTables(scope, lambdaFunction, props.dynamoTableNames);
-
-  addLambdaLayers(scope, lambdaFunction, props.lambdaLayerArn);
-
-  return lambdaFunction;
-};
-
-const createBasicLambdaProps = (props: TimerJobProps): NodejsFunctionProps => {
-  const resolvedProjectRoot = resolveProjectRoot(props.projectRoot);
-  const defaultRelativeEntry = path.join(
-    "resources",
-    "lambdas",
-    "timer-jobs",
-    props.functionName,
-    "main.mts"
-  );
-  const entryPath = props.codePath ?? defaultRelativeEntry;
-  const resolvedEntry = resolvePath(entryPath, resolvedProjectRoot);
-
-  const cwd = path.resolve(process.cwd());
-  const entryDir = path.dirname(resolvedEntry);
-
-  let effectiveProjectRoot = resolvedProjectRoot ?? cwd;
-  if (!isSubPath(effectiveProjectRoot, resolvedEntry)) {
-    const ancestor = findCommonAncestor([effectiveProjectRoot, entryDir]);
-    if (!ancestor) {
-      throw new Error(
-        `Unable to determine a projectRoot that contains both ${effectiveProjectRoot} and ${resolvedEntry}.`
-      );
-    }
-    effectiveProjectRoot = ancestor;
-  }
-
-  if (!isSubPath(effectiveProjectRoot, resolvedEntry)) {
-    throw new Error(
-      `Resolved lambda entry ${resolvedEntry} must be located within projectRoot ${effectiveProjectRoot}.`
-    );
-  }
-
-  let resolvedDepsLockFilePath = props.depsLockFilePath
-    ? resolvePath(props.depsLockFilePath, resolvedProjectRoot)
-    : undefined;
-
-  if (!resolvedDepsLockFilePath) {
-    const potentialLockFiles = [
-      findNearestLockFile(entryDir),
-      findNearestLockFile(cwd),
-      effectiveProjectRoot !== cwd ? findNearestLockFile(effectiveProjectRoot) : undefined,
-    ];
-
-    for (const lockFile of potentialLockFiles) {
-      if (lockFile && isSubPath(effectiveProjectRoot, lockFile)) {
-        resolvedDepsLockFilePath = lockFile;
-        break;
-      }
-    }
-  }
-
-  if (
-    resolvedDepsLockFilePath &&
-    !isSubPath(effectiveProjectRoot, resolvedDepsLockFilePath)
-  ) {
-    throw new Error(
-      `Resolved depsLockFilePath ${resolvedDepsLockFilePath} must be located within projectRoot ${effectiveProjectRoot}.`
-    );
-  }
-
-  const environmentVars = props.envs ?? {};
-
-  const lambdaProp: NodejsFunctionProps = {
-    entry: resolvedEntry,
-    functionName: `${props.appPrefix ? `${props.appPrefix}-` : ""}${
-      props.functionName
-    }`,
-    handler: "main.ts",
-    logRetention: RetentionDays.TWO_WEEKS,
-    runtime: Runtime.NODEJS_LATEST,
-    timeout: Duration.minutes(
-      props.timeoutInMinutes ? props.timeoutInMinutes : 1
-    ),
-    memorySize: props.memory,
-    environment: {
-      ...environmentVars,
-    },
-    bundling: {
-      minify: true,
-      target: `esnext`,
-      sourceMap: true,
-      sourceMapMode: SourceMapMode.EXTERNAL,
-      environment: {
-        ...environmentVars,
-      },
-    },
-    role: props.role,
-    layers: undefined,
-    ...(effectiveProjectRoot && { projectRoot: effectiveProjectRoot }),
-    ...(resolvedDepsLockFilePath && {
-      depsLockFilePath: resolvedDepsLockFilePath,
-    }),
-  };
-
-  return lambdaProp;
-};
-
-const addInvokePermissionToLambdaForEvents = (lambda: NodejsFunction) => {
-  lambda.addPermission(`InvokePermission-${lambda.functionName}`, {
-    principal: new ServicePrincipal(SERVICE_PRINCIPAL.EVENTS),
-  });
-};
-
-const createEventRuleForLambda = (
-  scope: Construct,
-  lambda: NodejsFunction,
-  options: CronOptions
-) => {
-  const eventRule = new Rule(
-    scope,
-    `scheduleRule-${lambda?.node.id || "010"}`,
-    {
-      schedule: Schedule.cron(options),
-    }
-  );
-
-  return eventRule;
-};
-
-const grantAccessToDynamoTables = (
-  scope: Construct,
-  lambda: NodejsFunction,
-  tableNames?: string[]
-) => {
-  if (tableNames && tableNames.length > 0) {
-    tableNames.forEach((tableName) => {
-      const table = Table.fromTableName(scope, `${tableName}-table`, tableName);
-
-      table.grantReadWriteData(lambda);
-    });
-  }
-};
-
-const addLambdaLayers = (
-  scope: Construct,
-  lambda: NodejsFunction,
-  layerArns?: string[]
-) => {
-  if (layerArns && layerArns.length > 0) {
-    layerArns.forEach((arn: string, idx: number) => {
-      const layer = LayerVersion.fromLayerVersionArn(
-        scope,
-        `common-layer-${idx}`,
-        arn
-      );
-
-      lambda.addLayers(layer);
-    });
-  }
-};
+import { Duration } from "aws-cdk-lib";
+import { ServicePrincipal } from "aws-cdk-lib/aws-iam";
+import { LayerVersion, Runtime } from "aws-cdk-lib/aws-lambda";
+import {
+  NodejsFunction,
+  NodejsFunctionProps,
+  SourceMapMode,
+} from "aws-cdk-lib/aws-lambda-nodejs";
+import { RetentionDays } from "aws-cdk-lib/aws-logs";
+import path = require("path");
+import { TimerJobProps } from "../../interfaces/timer-job";
+import { Construct } from "constructs";
+import { SERVICE_PRINCIPAL } from "../../constants/aws-service-principal-constants";
+import { CronOptions, Rule, Schedule } from "aws-cdk-lib/aws-events";
+import { LambdaFunction } from "aws-cdk-lib/aws-events-targets";
+import { Table } from "aws-cdk-lib/aws-dynamodb";
+
+export const createBasicLambdaTimerJob = (
+  scope: Construct,
+  props: TimerJobProps
+): NodejsFunction => {
+  const lambdaProps = createBasicLambdaProps(props);
+
+  const functionName = `${props.appPrefix}${props.functionName}`;
+
+  let lambdaFunction = new NodejsFunction(
+    scope,
+    functionName,
+    lambdaProps
+  );
+
+  addInvokePermissionToLambdaForEvents(lambdaFunction, functionName);
+
+  const eventRule = createEventRuleForLambda(
+    scope,
+    lambdaFunction,
+    props.cronOptions
+  );
+
+  eventRule.addTarget(new LambdaFunction(lambdaFunction));
+
+  grantAccessToDynamoTables(scope, lambdaFunction, props.dynamoTableNames);
+
+  addLambdaLayers(scope, lambdaFunction, props.lambdaLayerArn);
+
+  return lambdaFunction;
+};
+
+const createBasicLambdaProps = (props: TimerJobProps): NodejsFunctionProps => {
+  let resolvedEntry: string;
+
+  if (props.codePath && path.isAbsolute(props.codePath)) {
+    resolvedEntry = props.codePath;
+  } else if (props.codePath && props.projectRoot) {
+    // codePath is relative, resolve from current directory + projectRoot
+    resolvedEntry = path.resolve(process.cwd(), props.codePath);
+  } else if (props.projectRoot) {
+    // No codePath, use default path with projectRoot
+    resolvedEntry = path.resolve(
+      process.cwd(),
+      props.projectRoot,
+      `resources/lambdas/timer-jobs/${props.functionName}/main.mts`
+    );
+  } else if (props.codePath) {
+    // codePath without projectRoot
+    resolvedEntry = path.resolve(process.cwd(), props.codePath);
+  } else {
+    // Default path without projectRoot
+    resolvedEntry = path.join(
+      `./resources/lambdas/timer-jobs/${props.functionName}/main.mts`
+    );
+  }
+
+  const lambdaProp: NodejsFunctionProps = {
+    entry: resolvedEntry,
+    functionName: `${props.appPrefix ? `${props.appPrefix}-` : ""}${
+      props.functionName
+    }`,
+    handler: "main.ts",
+    logRetention: RetentionDays.TWO_WEEKS,
+    runtime: Runtime.NODEJS_LATEST,
+    timeout: Duration.minutes(
+      props.timeoutInMinutes ? props.timeoutInMinutes : 1
+    ),
+    memorySize: props.memory,
+    environment: {
+      ...props.envs,
+    },
+    bundling: {
+      minify: true,
+      target: `esnext`,
+      sourceMap: true,
+      sourceMapMode: SourceMapMode.EXTERNAL,
+      environment: {
+        ...props.envs,
+      },
+      ...(props.projectRoot && { projectRoot: props.projectRoot }),
+      ...(props.depsLockFilePath && {
+        depsLockFilePath: props.depsLockFilePath,
+      }),
+    },
+    role: props.role,
+    layers: undefined,
+  };
+
+  return lambdaProp;
+};
+
+const addInvokePermissionToLambdaForEvents = (lambda: NodejsFunction, functionName: string) => {
+  lambda.addPermission(`InvokePermission-${functionName}`, {
+    principal: new ServicePrincipal(SERVICE_PRINCIPAL.EVENTS),
+  });
+};
+
+const createEventRuleForLambda = (
+  scope: Construct,
+  lambda: NodejsFunction,
+  options: CronOptions
+) => {
+  const eventRule = new Rule(
+    scope,
+    `scheduleRule-${lambda?.node.id || "010"}`,
+    {
+      schedule: Schedule.cron(options),
+    }
+  );
+
+  return eventRule;
+};
+
+const grantAccessToDynamoTables = (
+  scope: Construct,
+  lambda: NodejsFunction,
+  tableNames?: string[]
+) => {
+  if (tableNames && tableNames.length > 0) {
+    tableNames.forEach((tableName) => {
+      const table = Table.fromTableName(scope, `${tableName}-table`, tableName);
+
+      table.grantReadWriteData(lambda);
+    });
+  }
+};
+
+const addLambdaLayers = (
+  scope: Construct,
+  lambda: NodejsFunction,
+  layerArns?: string[]
+) => {
+  if (layerArns && layerArns.length > 0) {
+    layerArns.forEach((arn: string, idx: number) => {
+      const layer = LayerVersion.fromLayerVersionArn(
+        scope,
+        `common-layer-${idx}`,
+        arn
+      );
+
+      lambda.addLayers(layer);
+    });
+  }
+};