@goldstack/template-lambda-api 0.4.41 → 0.4.44

package/schemas/package.schema.json

@@ -1,244 +0,0 @@
-{
-  "$schema": "http://json-schema.org/draft-07/schema#",
-  "$ref": "#/definitions/ThisPackage",
-  "definitions": {
-    "ThisPackage": {
-      "type": "object",
-      "properties": {
-        "template": {
-          "$ref": "#/definitions/Template"
-        },
-        "templateVersion": {
-          "$ref": "#/definitions/TemplateVersion"
-        },
-        "name": {
-          "$ref": "#/definitions/Name"
-        },
-        "configuration": {
-          "$ref": "#/definitions/ThisPackageConfiguration"
-        },
-        "deployments": {
-          "$ref": "#/definitions/LambdaApiDeployments"
-        },
-        "$schema": {
-          "type": "string"
-        }
-      },
-      "required": [
-        "$schema",
-        "configuration",
-        "deployments",
-        "name",
-        "template",
-        "templateVersion"
-      ],
-      "additionalProperties": false,
-      "description": "A deployment for a lambda API.",
-      "title": "Lambda API Package"
-    },
-    "Template": {
-      "type": "string",
-      "description": "Name of the template used for creating this package.",
-      "title": "Template",
-      "pattern": "^[^\\s]*$"
-    },
-    "TemplateVersion": {
-      "type": "string",
-      "description": "Latest template version that was applied to this package.",
-      "title": "Template Version"
-    },
-    "Name": {
-      "type": "string",
-      "description": "Name of this package.",
-      "title": "Package Name"
-    },
-    "ThisPackageConfiguration": {
-      "$ref": "#/definitions/PackageConfiguration",
-      "description": "Configures this lambda.",
-      "title": "Lambda Configuration"
-    },
-    "PackageConfiguration": {
-      "type": "object",
-      "description": "Configuration of this package",
-      "title": "Configuration"
-    },
-    "LambdaApiDeployments": {
-      "type": "array",
-      "items": {
-        "$ref": "#/definitions/ThisDeployment"
-      },
-      "description": "Places where the lambda should be deployed to.",
-      "title": "Deployments"
-    },
-    "ThisDeployment": {
-      "type": "object",
-      "properties": {
-        "name": {
-          "$ref": "#/definitions/DeploymentName"
-        },
-        "configuration": {
-          "$ref": "#/definitions/ThisDeploymentConfiguration"
-        },
-        "terraformVariables": {
-          "$ref": "#/definitions/TerraformVariables"
-        },
-        "tfStateKey": {
-          "$ref": "#/definitions/TerraformStateKey"
-        },
-        "tfVersion": {
-          "$ref": "#/definitions/TerraformVersion"
-        },
-        "awsRegion": {
-          "$ref": "#/definitions/AWSDeploymentRegion"
-        },
-        "awsUser": {
-          "$ref": "#/definitions/AWSUserName"
-        }
-      },
-      "required": [
-        "awsRegion",
-        "awsUser",
-        "configuration",
-        "name"
-      ]
-    },
-    "DeploymentName": {
-      "type": "string",
-      "description": "Identifier for this deployment. No spaces allowed in name.",
-      "title": "Deployment Name",
-      "pattern": "^[^\\s]*$"
-    },
-    "ThisDeploymentConfiguration": {
-      "type": "object",
-      "properties": {
-        "lambdaNamePrefix": {
-          "type": "string",
-          "description": "The prefix to be used for names of the generated lambdas for the API endpoints.",
-          "title": "Lambda Name Prefix",
-          "pattern": "^[A-Za-z0-9-_]*$"
-        },
-        "apiDomain": {
-          "$ref": "#/definitions/APIDomain"
-        },
-        "hostedZoneDomain": {
-          "$ref": "#/definitions/HostedZoneDomain"
-        },
-        "cors": {
-          "$ref": "#/definitions/CorsHeader"
-        },
-        "lambdas": {
-          "$ref": "#/definitions/LambdaRoutesConfig"
-        }
-      },
-      "required": [
-        "apiDomain",
-        "hostedZoneDomain",
-        "lambdas"
-      ]
-    },
-    "APIDomain": {
-      "type": "string",
-      "description": "The domain name that the API should be deployed to (e.g. api.mysite.com)",
-      "title": "API Domain",
-      "pattern": "^[^\\s]*"
-    },
-    "HostedZoneDomain": {
-      "type": "string",
-      "description": "The domain name of the Route 53 hosted zone that the domain for this API should be added to.",
-      "title": "Hosted Zone Domain",
-      "pattern": "^[^\\s]*"
-    },
-    "CorsHeader": {
-      "type": "string",
-      "description": "Optional URL for an UI that should be allowed to access this server.",
-      "title": "CORS Header",
-      "pattern": "^[^\\s]*"
-    },
-    "LambdaRoutesConfig": {
-      "type": "object",
-      "additionalProperties": {
-        "$ref": "#/definitions/LambdaRouteConfig"
-      }
-    },
-    "LambdaRouteConfig": {
-      "type": "object",
-      "properties": {
-        "function_name": {
-          "type": "string"
-        },
-        "route": {
-          "type": "string"
-        }
-      },
-      "required": [
-        "function_name",
-        "route"
-      ],
-      "additionalProperties": false
-    },
-    "TerraformVariables": {
-      "type": "array",
-      "items": {
-        "$ref": "#/definitions/TerraformVariable"
-      },
-      "description": "Define which of the deployment variables will be made available for terraform.",
-      "title": "Terraform Variables"
-    },
-    "TerraformVariable": {
-      "type": "string",
-      "description": "Name of the property that should be converted into a Terraform variable.",
-      "title": "Terraform Variable"
-    },
-    "TerraformStateKey": {
-      "type": "string",
-      "description": "Key used for Terraform state persisted in Terraform state bucket.\n\nWill be auto-generated upon first deployment if not provided.",
-      "title": "Terraform State Key"
-    },
-    "TerraformVersion": {
-      "type": "string",
-      "enum": [
-        "0.12",
-        "0.13",
-        "0.14",
-        "0.15",
-        "1.0",
-        "1.1"
-      ],
-      "description": "Version of Terraform that the remote state for this deployment was created with.\n\nGo to the next version using `yarn infra upgrade [deploymentName] [targetVersion]`. Note that Terraform versions should only be increased one at a time, so for instance you can go from v0.12 to v0.13 but not from v0.12 to v0.14.",
-      "default": "0.12"
-    },
-    "AWSDeploymentRegion": {
-      "type": "string",
-      "enum": [
-        "us-east-1",
-        "us-east-2",
-        "us-west-1",
-        "us-west-2",
-        "af-south-1",
-        "ap-east-1",
-        "ap-south-1",
-        "ap-northeast-3",
-        "ap-northeast-2",
-        "ap-southeast-1",
-        "ap-southeast-2",
-        "ap-northeast-1",
-        "ca-central-1",
-        "eu-central-1",
-        "eu-west-1",
-        "eu-west-2",
-        "eu-south-1",
-        "eu-west-3",
-        "eu-north-1",
-        "me-south-1",
-        "sa-east-1"
-      ],
-      "description": "AWS region that infrastructure should be deployed to.",
-      "title": "AWS Deployment Region"
-    },
-    "AWSUserName": {
-      "type": "string",
-      "description": "Name of the AWS user that is used to perform the deployment.",
-      "title": "AWS User Name"
-    }
-  }
-}

package/scripts/buildTestLambdas.ts

@@ -1,23 +0,0 @@
-import path from 'path';
-import { buildLambdas } from './../src/templateLambdaApiBuild';
-import { RouteType } from '@goldstack/utils-aws-lambda';
-
-const fileToBuild = path.resolve('./testData/build-test/index.ts');
-
-(async () => {
-  await buildLambdas({
-    routesDir: './testData/build-test',
-    configs: [
-      {
-        path: '/index',
-        relativeFilePath: 'index.ts',
-        name: 'test-lambda-index',
-        absoluteFilePath: fileToBuild,
-        route: 'ANY /',
-        type: RouteType.FUNCTION,
-      },
-    ],
-  });
-})().then(() => {
-  console.log('done');
-});

package/scripts/generateSchemas.ts

@@ -1,3 +0,0 @@
-import { run } from '@goldstack/utils-package-config-generate';
-
-run(process.argv);

package/src/generateLambdaConfig.spec.ts

@@ -1,97 +0,0 @@
-import {
-  readLambdaConfig,
-  generateFunctionName,
-} from '@goldstack/utils-aws-lambda';
-import assert from 'assert';
-import { generateLambdaConfig } from './generateLambdaConfig';
-import { LambdaApiDeployment } from './templateLambdaApi';
-import { getOutDirForLambda } from './templateLambdaApiBuild';
-
-const dummyDeployment: LambdaApiDeployment = {
-  awsRegion: 'ap-east-1',
-  awsUser: 'dummy',
-  configuration: {
-    lambdaNamePrefix: 'test-lambdas',
-    apiDomain: 'domain',
-    hostedZoneDomain: 'domain',
-    lambdas: {},
-  },
-  name: 'test',
-};
-
-describe('Generate Lambda config', () => {
-  const routesConfig = readLambdaConfig('./testData/routes-test');
-  const config = generateLambdaConfig(dummyDeployment, routesConfig);
-  test('Should render config for Terraform', () => {
-    assert(config['default'].function_name);
-    assert(
-      config['ANY /folder/nested'].function_name.indexOf(
-        dummyDeployment.configuration.lambdaNamePrefix || 'fail'
-      ) !== -1
-    );
-  });
-  test('Should determine correct output dirs for dist', () => {
-    const nestedRoute = routesConfig.find((e) => e.path === '/folder/nested');
-    assert(nestedRoute);
-    const dir = getOutDirForLambda(nestedRoute);
-    assert(dir === './distLambda/folder/nested');
-  });
-  test('Should determine path parametmers for file names', () => {
-    const nestedRoute = routesConfig.find(
-      (e) => e.path === '/folder/{pathparam}'
-    );
-    assert(nestedRoute);
-    const functionName = generateFunctionName(
-      dummyDeployment.configuration.lambdaNamePrefix,
-      nestedRoute
-    );
-    assert(functionName.indexOf('folder') !== -1);
-    assert(functionName.indexOf('{') === -1);
-    assert(functionName.indexOf('}') === -1);
-  });
-  test('Should determine path parametmers for folder names', () => {
-    const nestedRoute = routesConfig.find(
-      (e) => e.path === '/resource/{path}/object'
-    );
-    assert(nestedRoute);
-    const functionName = generateFunctionName(
-      dummyDeployment.configuration.lambdaNamePrefix,
-      nestedRoute
-    );
-    assert(functionName.indexOf('object') !== -1);
-    assert(functionName.indexOf('resource') !== -1);
-    assert(functionName.indexOf('{') === -1);
-    assert(functionName.indexOf('}') === -1);
-  });
-  test('Should provide a correct path for a nested index file', () => {
-    const nestedRoute = routesConfig.find((e) => e.path === '/health');
-    assert(nestedRoute);
-
-    const functionName = generateFunctionName(
-      dummyDeployment.configuration.lambdaNamePrefix,
-      nestedRoute
-    );
-    expect(functionName).toContain('health');
-  });
-  test('Should provide a correct path for a file in the API root', () => {
-    const nestedRoute = routesConfig.find((e) => e.path === '/resource');
-    assert(nestedRoute);
-
-    const functionName = generateFunctionName(
-      dummyDeployment.configuration.lambdaNamePrefix,
-      nestedRoute
-    );
-    assert(functionName.match(/resource/g)?.length === 1);
-  });
-  test('Should hash long names', () => {
-    const nestedRoute = routesConfig.find((e) => e.path === '/resource');
-    assert(nestedRoute);
-
-    const functionName = generateFunctionName(
-      'very_long_names_should_end_with_a_hash_and_never_be_longer_than_64_characters',
-      nestedRoute
-    );
-    expect(functionName.length <= 64).toBeTruthy();
-    expect(functionName.indexOf('characters') === -1).toBe(true);
-  });
-});

package/src/generateLambdaConfig.ts

@@ -1,37 +0,0 @@
-import {
-  LambdaConfig,
-  generateFunctionName,
-} from '@goldstack/utils-aws-lambda';
-import {
-  LambdaRoutesConfig,
-  LambdaApiDeployment,
-} from './types/LambdaApiPackage';
-
-export const generateLambdaConfig = (
-  deployment: LambdaApiDeployment,
-  config: LambdaConfig[]
-): LambdaRoutesConfig => {
-  return config.reduce((last, curr) => {
-    let id = curr.route;
-    if (id === '$default') {
-      id = 'default';
-    }
-    last[`${id}`] = {
-      function_name: generateFunctionName(
-        deployment.configuration.lambdaNamePrefix,
-        curr
-      ),
-      route: curr.route,
-    };
-    return last;
-  }, {});
-};
-
-export const validateDeployment = (config: LambdaRoutesConfig): boolean => {
-  let valid = true;
-  for (const e of Object.entries(config)) {
-    valid = valid && e[0].length > 0;
-    valid = valid && !!e[1].function_name && e[1].function_name.length > 0;
-  }
-  return valid;
-};

package/src/templateLambdaApi.ts

@@ -1,88 +0,0 @@
-import { buildCli, buildDeployCommands } from '@goldstack/utils-package';
-import { wrapCli } from '@goldstack/utils-cli';
-import { infraCommands } from '@goldstack/utils-terraform';
-import { deployCli } from './templateLambdaApiDeploy';
-import { terraformAwsCli } from '@goldstack/utils-terraform-aws';
-import { PackageConfig } from '@goldstack/utils-package-config';
-import { writePackageConfig } from '@goldstack/utils-package';
-export * from './types/LambdaApiPackage';
-import yargs from 'yargs';
-import fs from 'fs';
-import {
-  LambdaApiPackage,
-  LambdaApiDeployment,
-} from './types/LambdaApiPackage';
-import { readLambdaConfig } from '@goldstack/utils-aws-lambda';
-import {
-  generateLambdaConfig,
-  validateDeployment,
-} from './generateLambdaConfig';
-import { defaultRoutesPath } from './templateLambdaConsts';
-import { buildLambdas } from './templateLambdaApiBuild';
-
-export const run = async (args: string[]): Promise<void> => {
-  await wrapCli(async () => {
-    const argv = buildCli({
-      yargs,
-      deployCommands: buildDeployCommands(),
-      infraCommands: infraCommands(),
-    })
-      .command('build [deployment]', 'Build all lambdas', () => {
-        return yargs.positional('deployment', {
-          type: 'string',
-          describe: 'Name of the deployment this command should be applied to',
-          default: '',
-        });
-      })
-      .help().argv;
-
-    const packageConfig = new PackageConfig<
-      LambdaApiPackage,
-      LambdaApiDeployment
-    >({
-      packagePath: './',
-    });
-
-    const config = packageConfig.getConfig();
-
-    // update routes
-    if (!fs.existsSync('./src/routes')) {
-      throw new Error(
-        'Please specify lambda function handlers in ./src/routes so that API Gateway route configuration can be generated.'
-      );
-    }
-    const lambdaRoutes = readLambdaConfig(defaultRoutesPath);
-    config.deployments = config.deployments.map((e) => {
-      const lambdasConfigs = generateLambdaConfig(e, lambdaRoutes);
-      e.configuration.lambdas = lambdasConfigs;
-      validateDeployment(e.configuration.lambdas);
-      return e;
-    });
-    writePackageConfig(config);
-
-    const command = argv._[0];
-    const [, , , ...opArgs] = args;
-
-    if (command === 'infra') {
-      await terraformAwsCli(opArgs);
-      return;
-    }
-
-    if (command === 'build') {
-      await buildLambdas({
-        routesDir: defaultRoutesPath,
-        configs: lambdaRoutes,
-        lambdaNamePrefix: packageConfig.getDeployment(opArgs[0]).configuration
-          .lambdaNamePrefix,
-      });
-      return;
-    }
-
-    if (command === 'deploy') {
-      await deployCli(packageConfig.getDeployment(opArgs[0]), lambdaRoutes);
-      return;
-    }
-
-    throw new Error('Unknown command: ' + command);
-  });
-};

package/src/templateLambdaApiBuild.spec.ts

@@ -1,49 +0,0 @@
-import { RouteType } from '@goldstack/utils-aws-lambda';
-import { read } from '@goldstack/utils-sh';
-import path from 'path';
-import { buildLambdas } from './templateLambdaApiBuild';
-import fs from 'fs';
-
-jest.setTimeout(30000);
-
-describe('Testing lambda build', () => {
-  it('Should build lambda', async () => {
-    const fileToBuild = path.resolve('./testData/build-test/index.ts');
-    expect(fs.existsSync(fileToBuild)).toEqual(true);
-    await buildLambdas({
-      routesDir: './testData/build-test',
-      configs: [
-        {
-          path: '/index',
-          relativeFilePath: 'index.ts',
-          name: 'test-lambda-index',
-          absoluteFilePath: fileToBuild,
-          route: 'ANY /',
-          type: RouteType.FUNCTION,
-        },
-      ],
-    });
-    const generated = read('./distLambda/index/lambda.js');
-    expect(generated.length).toBeGreaterThan(100);
-  });
-
-  it('Should build lambda with custom esbuild config', async () => {
-    await buildLambdas({
-      routesDir: './testData/build-test',
-      configs: [
-        {
-          path: '/customBuild',
-          relativeFilePath: 'customBuild.ts',
-          name: 'test-lambda-customBuild',
-          absoluteFilePath: path.resolve(
-            './testData/build-test/customBuild.ts'
-          ),
-          route: 'ANY /',
-          type: RouteType.FUNCTION,
-        },
-      ],
-    });
-    const generated = read('./distLambda/customBuild/lambda.js');
-    expect(generated).toContain('Custom config in operation');
-  });
-});

package/src/templateLambdaApiBuild.ts

@@ -1,72 +0,0 @@
-import { build, BuildOptions } from 'esbuild';
-import { pnpPlugin } from '@yarnpkg/esbuild-plugin-pnp';
-import {
-  generateFunctionName,
-  LambdaConfig,
-} from '@goldstack/utils-aws-lambda';
-import {
-  changeExtension,
-  mkdir,
-  readToType,
-  rmSafe,
-  write,
-} from '@goldstack/utils-sh';
-import { LambdaApiDeployment } from './types/LambdaApiPackage';
-
-export const getOutDirForLambda = (config: LambdaConfig): string => {
-  if (config.path === '$default') {
-    return `./distLambda/${config.path}`;
-  }
-  return `./distLambda${config.path}`;
-};
-
-export const getOutFileForLambda = (config: LambdaConfig): string => {
-  return `${getOutDirForLambda(config)}/lambda.js`;
-};
-
-export const buildLambdas = async ({
-  routesDir,
-  configs,
-  lambdaNamePrefix,
-}: {
-  routesDir: string;
-  configs: LambdaConfig[];
-  lambdaNamePrefix?: string;
-}): Promise<void> => {
-  const esbuildConfig = readToType<BuildOptions>('./esbuild.config.json');
-
-  await rmSafe('./distLambda');
-  mkdir('-p', './distLambda/zips');
-  for await (const config of configs) {
-    mkdir('-p', getOutDirForLambda(config));
-    const esbuildLocalPath = changeExtension(
-      `${routesDir}/${config.relativeFilePath}`,
-      '.esbuild.config.json'
-    );
-    const functionName = generateFunctionName(lambdaNamePrefix, config);
-    const localEsbuildConfig = readToType<BuildOptions>(esbuildLocalPath);
-
-    const res = await build({
-      plugins: [pnpPlugin()],
-      bundle: true,
-      entryPoints: [`${routesDir}/${config.relativeFilePath}`],
-      external: ['aws-sdk', 'mock-aws-s3', 'testcontainers'], // mock-aws-s3 from s3 template, testcontainers from dynamodb template
-      minify: true,
-      platform: 'node',
-      format: 'cjs',
-      target: 'node16.0',
-      sourcemap: true,
-      outfile: getOutFileForLambda(config),
-      metafile: true,
-      ...esbuildConfig,
-      ...localEsbuildConfig,
-    });
-    if (!res.metafile) {
-      throw new Error(`Metafile for ${functionName} not defined.`);
-    }
-    write(
-      JSON.stringify(res.metafile),
-      `./distLambda/zips/${functionName}.meta.json`
-    );
-  }
-};

package/src/templateLambdaApiDeploy.ts

@@ -1,54 +0,0 @@
-import { LambdaApiDeployment } from './types/LambdaApiPackage';
-import { getAWSUser } from '@goldstack/infra-aws';
-import {
-  deployFunction,
-  LambdaConfig,
-  generateFunctionName,
-} from '@goldstack/utils-aws-lambda';
-
-import { readLambdaConfig } from '@goldstack/utils-aws-lambda';
-import { defaultRoutesPath } from './templateLambdaConsts';
-
-import { mkdir, rmSafe } from '@goldstack/utils-sh';
-import { getOutDirForLambda } from './templateLambdaApiBuild';
-
-interface DeployLambdaParams {
-  deployment: LambdaApiDeployment;
-  config: LambdaConfig[];
-}
-
-export const deployLambdas = async (
-  params: DeployLambdaParams
-): Promise<void> => {
-  const lambdaConfig = readLambdaConfig(defaultRoutesPath);
-
-  const operations = lambdaConfig.map(async (config) => {
-    const functionName = generateFunctionName(
-      params.deployment.configuration.lambdaNamePrefix,
-      config
-    );
-    console.log(`[${functionName}]: Starting deployment`);
-    const functionDir = getOutDirForLambda(config);
-    mkdir('-p', functionDir);
-    const targetArchive = `./distLambda/zips/${functionName}.zip`;
-    await deployFunction({
-      targetArchiveName: targetArchive,
-      lambdaPackageDir: functionDir,
-      awsCredentials: await getAWSUser(params.deployment.awsUser),
-      region: params.deployment.awsRegion,
-      functionName,
-    });
-    console.log(`[${functionName}]: Deployment completed`);
-  });
-  await Promise.all(operations);
-};
-
-export const deployCli = async (
-  deployment: LambdaApiDeployment,
-  config: LambdaConfig[]
-): Promise<void> => {
-  await deployLambdas({
-    deployment,
-    config,
-  });
-};

package/src/templateLambdaConsts.ts

@@ -1 +0,0 @@
-export const defaultRoutesPath = './src/routes';