@aws/nx-plugin 0.3.0 → 0.5.0

package/src/trpc/backend/__snapshots__/generator.spec.ts.snap

@@ -1,18 +1,329 @@
 // Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html
 
-exports[`trpc backend generator > should generate backend and schema projects > backend-index.ts 1`] = `
-"export * from './lambdas/index.js';
+exports[`trpc backend generator > should generate backend and schema projects > apps/test-api/backend/src/client/index.ts 1`] = `
+"import {
+  createTRPCClient,
+  httpBatchLink,
+  httpLink,
+  HTTPBatchLinkOptions,
+  HTTPLinkOptions,
+  splitLink,
+} from '@trpc/client';
+
+import { AppRouter } from '../router.js';
+import { sigv4Fetch } from './sigv4.js';
+
+export interface TestApiClientConfig {
+  readonly url: string;
+}
+
+export const createTestApiClient = (config: TestApiClientConfig) => {
+  const linkOptions: HTTPLinkOptions<any> & HTTPBatchLinkOptions<any> = {
+    url: config.url,
+    fetch: sigv4Fetch,
+  };
+  return createTRPCClient<AppRouter>({
+    links: [
+      splitLink({
+        condition(op) {
+          return op.context.skipBatch === true;
+        },
+        true: httpLink(linkOptions),
+        false: httpBatchLink(linkOptions),
+      }),
+    ],
+  });
+};
+"
+`;
+
+exports[`trpc backend generator > should generate backend and schema projects > apps/test-api/backend/src/client/sigv4.ts 1`] = `
+"import { AwsClient } from 'aws4fetch';
+import { fromNodeProviderChain } from '@aws-sdk/credential-providers';
+
+const credentialProvider = fromNodeProviderChain();
+
+export const sigv4Fetch = (async (...args) => {
+  const client = new AwsClient(await credentialProvider());
+  return client.fetch(...args);
+}) satisfies AwsClient['fetch'];
+"
+`;
+
+exports[`trpc backend generator > should generate backend and schema projects > apps/test-api/backend/src/index.ts 1`] = `
+"export type { AppRouter } from './router.js';
+export type { Context } from './init.js';
+export * from './client/index.js';
+"
+`;
+
+exports[`trpc backend generator > should generate backend and schema projects > apps/test-api/backend/src/init.ts 1`] = `
+"import { initTRPC } from '@trpc/server';
+import {
+  createErrorPlugin,
+  createLoggerPlugin,
+  createMetricsPlugin,
+  createTracerPlugin,
+  IMiddlewareContext,
+} from './middleware/index.js';
+
+export type Context = IMiddlewareContext;
+
+export const t = initTRPC.context<Context>().create();
+
+export const publicProcedure = t.procedure
+  .unstable_concat(createLoggerPlugin())
+  .unstable_concat(createTracerPlugin())
+  .unstable_concat(createMetricsPlugin())
+  .unstable_concat(createErrorPlugin());
 "
 `;
 
-exports[`trpc backend generator > should generate backend and schema projects > schema-index.ts 1`] = `
+exports[`trpc backend generator > should generate backend and schema projects > apps/test-api/backend/src/local-server.ts 1`] = `
+"import { createHTTPServer } from '@trpc/server/adapters/standalone';
+import { appRouter } from './router.js';
+
+const PORT = 2022;
+
+createHTTPServer({
+  router: appRouter,
+  createContext() {
+    return {
+      event: {} as any,
+      context: {} as any,
+      info: {} as any,
+    };
+  },
+}).listen(PORT);
+
+console.log(\`Local TRPC server listening on port \${PORT}\`);
+"
+`;
+
+exports[`trpc backend generator > should generate backend and schema projects > apps/test-api/backend/src/middleware/error.ts 1`] = `
+"import { initTRPC, TRPCError } from '@trpc/server';
+
+export const createErrorPlugin = () => {
+  const t = initTRPC.context().create();
+  return t.procedure.use(async (opts) => {
+    const response = await opts.next({
+      ctx: {
+        ...opts.ctx,
+      },
+    });
+
+    if (!response.ok) {
+      if (response.error instanceof TRPCError) {
+        throw response.error;
+      }
+
+      throw new TRPCError({
+        code: 'INTERNAL_SERVER_ERROR',
+        message: 'An unexpected error occurred, please try again later.',
+        cause: response.error,
+      });
+    }
+
+    return response;
+  });
+};
+"
+`;
+
+exports[`trpc backend generator > should generate backend and schema projects > apps/test-api/backend/src/middleware/index.ts 1`] = `
+"import { CreateAWSLambdaContextOptions } from '@trpc/server/adapters/aws-lambda';
+import type { APIGatewayProxyEventV2WithIAMAuthorizer } from 'aws-lambda';
+import { ILoggerContext } from './logger.js';
+import { IMetricsContext } from './metrics.js';
+import { ITracerContext } from './tracer.js';
+
+export * from './logger.js';
+export * from './metrics.js';
+export * from './tracer.js';
+export * from './error.js';
+
+export type IMiddlewareContext =
+  CreateAWSLambdaContextOptions<APIGatewayProxyEventV2WithIAMAuthorizer> &
+    ILoggerContext &
+    IMetricsContext &
+    ITracerContext;
+"
+`;
+
+exports[`trpc backend generator > should generate backend and schema projects > apps/test-api/backend/src/middleware/logger.ts 1`] = `
+"import { initTRPC } from '@trpc/server';
+import { Logger } from '@aws-lambda-powertools/logger';
+
+export interface ILoggerContext {
+  logger?: Logger;
+}
+
+export const createLoggerPlugin = () => {
+  const t = initTRPC.context<ILoggerContext>().create();
+  return t.procedure.use(async (opts) => {
+    const logger = new Logger();
+
+    const response = await opts.next({
+      ctx: {
+        ...opts.ctx,
+        logger,
+      },
+    });
+
+    if (!response.ok) {
+      logger.error('Unexpected error occured', response.error.cause ?? '');
+    }
+
+    return response;
+  });
+};
+"
+`;
+
+exports[`trpc backend generator > should generate backend and schema projects > apps/test-api/backend/src/middleware/metrics.ts 1`] = `
+"import { initTRPC } from '@trpc/server';
+import { Metrics, MetricUnit } from '@aws-lambda-powertools/metrics';
+
+export interface IMetricsContext {
+  metrics?: Metrics;
+}
+
+export const createMetricsPlugin = () => {
+  const t = initTRPC.context<IMetricsContext>().create();
+
+  return t.procedure.use(async (opts) => {
+    const metrics = new Metrics();
+    metrics.captureColdStartMetric();
+
+    metrics.addMetric('requestCount', MetricUnit.Count, 1);
+
+    try {
+      const response = await opts.next({
+        ctx: {
+          ...opts.ctx,
+          metrics,
+        },
+      });
+
+      if (!response.ok) {
+        metrics.addMetric('errorCount', MetricUnit.Count, 1);
+      } else {
+        metrics.addMetric('successCount', MetricUnit.Count, 1);
+      }
+
+      return response;
+    } finally {
+      metrics.publishStoredMetrics();
+    }
+  });
+};
+"
+`;
+
+exports[`trpc backend generator > should generate backend and schema projects > apps/test-api/backend/src/middleware/tracer.ts 1`] = `
+"import { initTRPC } from '@trpc/server';
+import { Tracer } from '@aws-lambda-powertools/tracer';
+import { Subsegment } from 'aws-xray-sdk-core';
+
+export interface ITracerContext {
+  tracer?: Tracer;
+}
+
+export const createTracerPlugin = () => {
+  const t = initTRPC.context<ITracerContext>().create();
+
+  return t.procedure.use(async (opts) => {
+    const tracer = new Tracer();
+    const segment = tracer.getSegment();
+    let handlerSegment: Subsegment | undefined;
+
+    if (segment) {
+      handlerSegment = segment.addNewSubsegment(\`## \${opts.path}\`);
+      tracer.setSegment(handlerSegment);
+    }
+
+    tracer.annotateColdStart();
+    tracer.addServiceNameAnnotation();
+
+    try {
+      const response = await opts.next({
+        ctx: {
+          ...opts.ctx,
+          tracer,
+        },
+      });
+
+      if (!response.ok && response.error.cause instanceof Error) {
+        tracer.addErrorAsMetadata(response.error.cause);
+      }
+      return response;
+    } finally {
+      if (segment && handlerSegment) {
+        handlerSegment.close();
+        tracer.setSegment(segment);
+      }
+    }
+  });
+};
+"
+`;
+
+exports[`trpc backend generator > should generate backend and schema projects > apps/test-api/backend/src/procedures/echo.ts 1`] = `
+"import { publicProcedure } from '../init.js';
+import { EchoInputSchema, EchoOutputSchema } from ':proj/test-api-schema';
+
+export const echo = publicProcedure
+  .input(EchoInputSchema)
+  .output(EchoOutputSchema)
+  .query((opts) => ({ result: opts.input.message }));
+"
+`;
+
+exports[`trpc backend generator > should generate backend and schema projects > apps/test-api/backend/src/router.ts 1`] = `
+"import {
+  awsLambdaRequestHandler,
+  CreateAWSLambdaContextOptions,
+} from '@trpc/server/adapters/aws-lambda';
+import { echo } from './procedures/echo.js';
+import { t } from './init.js';
+import { APIGatewayProxyEventV2WithIAMAuthorizer } from 'aws-lambda';
+
+export const router = t.router;
+
+export const appRouter = router({
+  echo,
+});
+
+export const handler = awsLambdaRequestHandler({
+  router: appRouter,
+  createContext: (
+    ctx: CreateAWSLambdaContextOptions<APIGatewayProxyEventV2WithIAMAuthorizer>,
+  ) => ctx,
+});
+
+export type AppRouter = typeof appRouter;
+"
+`;
+
+exports[`trpc backend generator > should generate backend and schema projects > apps/test-api/schema/src/index.ts 1`] = `
+"export * from './procedures/echo.js';
+"
+`;
+
+exports[`trpc backend generator > should generate backend and schema projects > apps/test-api/schema/src/procedures/echo.ts 1`] = `
 "import { z } from 'zod';
 
-export const EchoSchema = z.object({
+export const EchoInputSchema = z.object({
+  message: z.string(),
+});
+
+export type IEchoInput = z.TypeOf<typeof EchoInputSchema>;
+
+export const EchoOutputSchema = z.object({
   result: z.string(),
 });
 
-export type IEcho = z.TypeOf<typeof EchoSchema>;
+export type IEchoOutput = z.TypeOf<typeof EchoOutputSchema>;
 "
 `;
 
@@ -33,7 +344,7 @@ export class TestApi extends TrpcApi {
       defaultAuthorizer: new HttpIamAuthorizer(),
       handlerFilePath: url.fileURLToPath(
         new URL(
-          '../../../../../../apps/test-api/backend/src/lambdas/router.ts',
+          '../../../../../../apps/test-api/backend/src/router.ts',
           import.meta.url,
         ),
       ),

package/src/trpc/backend/files/backend/README.md.template

@@ -28,6 +28,6 @@ You can also automatiaclly fix some lint errors by running the following command
 
 ## Useful links
 
-- [Trpc reference docs](TODO)
+- [tRPC reference docs](https://trpc.io/docs/)
 - [Learn more about NX](https://nx.dev/getting-started/intro)
 

package/src/trpc/backend/files/backend/src/client/index.ts.template

@@ -0,0 +1,33 @@
+import {
+  createTRPCClient,
+  httpBatchLink,
+  httpLink,
+  HTTPBatchLinkOptions,
+  HTTPLinkOptions,
+  splitLink,
+} from '@trpc/client';
+
+import { AppRouter } from "../router.js";
+import { sigv4Fetch } from './sigv4.js';
+
+export interface <%= apiNameClassName %>ClientConfig {
+  readonly url: string;
+}
+
+export const create<%= apiNameClassName %>Client = (config: <%= apiNameClassName %>ClientConfig) => {
+  const linkOptions: HTTPLinkOptions<any> & HTTPBatchLinkOptions<any> = {
+    url: config.url,
+    fetch: sigv4Fetch,
+  };
+  return createTRPCClient<AppRouter>({
+    links: [
+      splitLink({
+        condition(op) {
+          return op.context.skipBatch === true;
+        },
+        true: httpLink(linkOptions),
+        false: httpBatchLink(linkOptions),
+      }),
+    ],
+  });
+};

package/src/trpc/backend/files/backend/src/client/sigv4.ts.template

@@ -0,0 +1,9 @@
+import { AwsClient } from 'aws4fetch';
+import { fromNodeProviderChain } from '@aws-sdk/credential-providers';
+
+const credentialProvider = fromNodeProviderChain();
+
+export const sigv4Fetch = (async (...args) => {
+  const client = new AwsClient(await credentialProvider());
+  return client.fetch(...args);
+}) satisfies AwsClient['fetch'];

package/src/trpc/backend/files/backend/src/index.ts.template

@@ -1 +1,3 @@
-export * from './lambdas/index.js';
+export type { AppRouter } from './router.js';
+export type { Context } from './init.js';
+export * from './client/index.js';

package/src/trpc/backend/files/backend/src/init.ts.template

@@ -0,0 +1,18 @@
+import { initTRPC } from '@trpc/server';
+import {
+  createErrorPlugin,
+  createLoggerPlugin,
+  createMetricsPlugin,
+  createTracerPlugin,
+  IMiddlewareContext,
+} from './middleware/index.js';
+
+export type Context = IMiddlewareContext;
+
+export const t = initTRPC.context<Context>().create();
+
+export const publicProcedure = t.procedure
+  .unstable_concat(createLoggerPlugin())
+  .unstable_concat(createTracerPlugin())
+  .unstable_concat(createMetricsPlugin())
+  .unstable_concat(createErrorPlugin());

package/src/trpc/backend/files/backend/src/local-server.ts.template

@@ -0,0 +1,17 @@
+import { createHTTPServer } from '@trpc/server/adapters/standalone';
+import { appRouter } from './router.js';
+
+const PORT = 2022;
+
+createHTTPServer({
+  router: appRouter,
+  createContext() {
+    return {
+      event: {} as any,
+      context: {} as any,
+      info: {} as any,
+    };
+  },
+}).listen(PORT);
+
+console.log(`Local TRPC server listening on port ${PORT}`);

package/src/trpc/backend/files/backend/src/middleware/error.ts.template

@@ -0,0 +1,26 @@
+import { initTRPC, TRPCError } from '@trpc/server';
+
+export const createErrorPlugin = () => {
+  const t = initTRPC.context().create();
+  return t.procedure.use(async (opts) => {
+    const response = await opts.next({
+      ctx: {
+        ...opts.ctx,
+      },
+    });
+
+    if (!response.ok) {
+      if (response.error instanceof TRPCError) {
+        throw response.error;
+      }
+
+      throw new TRPCError({
+        code: 'INTERNAL_SERVER_ERROR',
+        message: 'An unexpected error occurred, please try again later.',
+        cause: response.error,
+      });
+    }
+
+    return response;
+  });
+};

package/src/trpc/backend/files/backend/src/middleware/index.ts.template

@@ -0,0 +1,15 @@
+import { CreateAWSLambdaContextOptions } from '@trpc/server/adapters/aws-lambda';
+import type { APIGatewayProxyEventV2WithIAMAuthorizer } from 'aws-lambda';
+import { ILoggerContext } from './logger.js';
+import { IMetricsContext } from './metrics.js';
+import { ITracerContext } from './tracer.js';
+
+export * from './logger.js';
+export * from './metrics.js';
+export * from './tracer.js';
+export * from './error.js';
+
+export type IMiddlewareContext = CreateAWSLambdaContextOptions<APIGatewayProxyEventV2WithIAMAuthorizer>
+  & ILoggerContext
+  & IMetricsContext
+  & ITracerContext;

package/src/trpc/backend/files/backend/src/middleware/logger.ts.template

@@ -0,0 +1,26 @@
+import { initTRPC } from '@trpc/server';
+import { Logger } from '@aws-lambda-powertools/logger';
+
+export interface ILoggerContext {
+  logger?: Logger;
+}
+
+export const createLoggerPlugin = () => {
+  const t = initTRPC.context<ILoggerContext>().create();
+  return t.procedure.use(async (opts) => {
+    const logger = new Logger();
+
+    const response = await opts.next({
+      ctx: {
+        ...opts.ctx,
+        logger,
+      },
+    });
+
+    if (!response.ok) {
+      logger.error('Unexpected error occured', response.error.cause ?? '');
+    }
+
+    return response;
+  });
+};

package/src/trpc/backend/files/backend/src/middleware/metrics.ts.template

@@ -0,0 +1,36 @@
+import { initTRPC } from '@trpc/server';
+import { Metrics, MetricUnit } from '@aws-lambda-powertools/metrics';
+
+export interface IMetricsContext {
+  metrics?: Metrics;
+}
+
+export const createMetricsPlugin = () => {
+  const t = initTRPC.context<IMetricsContext>().create();
+
+  return t.procedure.use(async (opts) => {
+    const metrics = new Metrics();
+    metrics.captureColdStartMetric();
+
+    metrics.addMetric('requestCount', MetricUnit.Count, 1);
+
+    try {
+      const response = await opts.next({
+        ctx: {
+          ...opts.ctx,
+          metrics,
+        },
+      });
+
+      if (!response.ok) {
+        metrics.addMetric('errorCount', MetricUnit.Count, 1);
+      } else {
+        metrics.addMetric('successCount', MetricUnit.Count, 1);
+      }
+
+      return response;
+    } finally {
+      metrics.publishStoredMetrics();
+    }
+  });
+};

package/src/trpc/backend/files/backend/src/middleware/tracer.ts.template

@@ -0,0 +1,44 @@
+import { initTRPC } from '@trpc/server';
+import { Tracer } from '@aws-lambda-powertools/tracer';
+import { Subsegment } from 'aws-xray-sdk-core';
+
+export interface ITracerContext {
+  tracer?: Tracer;
+}
+
+export const createTracerPlugin = () => {
+  const t = initTRPC.context<ITracerContext>().create();
+
+  return t.procedure.use(async (opts) => {
+    const tracer = new Tracer();
+    const segment = tracer.getSegment();
+    let handlerSegment: Subsegment | undefined;
+
+    if (segment) {
+      handlerSegment = segment.addNewSubsegment(`## ${opts.path}`);
+      tracer.setSegment(handlerSegment);
+    }
+
+    tracer.annotateColdStart();
+    tracer.addServiceNameAnnotation();
+
+    try {
+      const response = await opts.next({
+        ctx: {
+          ...opts.ctx,
+          tracer,
+        },
+      });
+
+      if (!response.ok && response.error.cause instanceof Error) {
+        tracer.addErrorAsMetadata(response.error.cause);
+      }
+      return response;
+    } finally {
+      if (segment && handlerSegment) {
+        handlerSegment.close();
+        tracer.setSegment(segment);
+      }
+    }
+  });
+};

package/src/trpc/backend/files/backend/src/procedures/echo.ts.template

@@ -0,0 +1,8 @@
+import { publicProcedure } from '../init.js';
+import { EchoInputSchema, EchoOutputSchema } from '<%= schemaProjectAlias %>';
+
+
+export const echo = publicProcedure
+  .input(EchoInputSchema)
+  .output(EchoOutputSchema)
+  .query((opts) => ({ result: opts.input.message }));

package/src/trpc/backend/files/backend/src/router.ts.template

@@ -0,0 +1,20 @@
+import {
+  awsLambdaRequestHandler,
+  CreateAWSLambdaContextOptions,
+} from '@trpc/server/adapters/aws-lambda';
+import { echo } from './procedures/echo.js';
+import { t } from './init.js';
+import { APIGatewayProxyEventV2WithIAMAuthorizer } from 'aws-lambda';
+
+export const router = t.router;
+
+export const appRouter = router({
+  echo,
+});
+
+export const handler = awsLambdaRequestHandler({
+  router: appRouter,
+  createContext: (ctx: CreateAWSLambdaContextOptions<APIGatewayProxyEventV2WithIAMAuthorizer>) => ctx,
+});
+
+export type AppRouter = typeof appRouter;

package/src/trpc/backend/files/common/constructs/src/app/trpc-apis/__apiNameKebabCase__.ts.template

@@ -9,7 +9,7 @@ export class <%= apiNameClassName %> extends TrpcApi {
         defaultAuthorizer: new HttpIamAuthorizer(),
         handlerFilePath: url.fileURLToPath(
             new URL(
-              '../../../<%= relativePathToProjectRoot %>/backend/src/lambdas/router.ts',
+              '../../../<%= relativePathToProjectRoot %>/backend/src/router.ts',
               import.meta.url
             )
           )

package/src/trpc/backend/files/schema/src/index.ts.template

@@ -1,7 +1 @@
-import { z } from 'zod';
-
-export const EchoSchema = z.object({
-  result: z.string(),
-});
-
-export type IEcho = z.TypeOf<typeof EchoSchema>;
+export * from './procedures/echo.js';

package/src/trpc/backend/files/schema/src/procedures/echo.ts.template

@@ -0,0 +1,13 @@
+import { z } from 'zod';
+
+export const EchoInputSchema = z.object({
+  message: z.string(),
+});
+
+export type IEchoInput = z.TypeOf<typeof EchoInputSchema>;
+
+export const EchoOutputSchema = z.object({
+  result: z.string(),
+});
+
+export type IEchoOutput = z.TypeOf<typeof EchoOutputSchema>;

package/src/trpc/backend/generator.js

@@ -64,6 +64,13 @@ function trpcBackendGenerator(tree, options) {
             config.metadata = {
                 apiName: options.apiName,
             };
+            config.targets = Object.assign(Object.assign({}, config.targets), { serve: {
+                    executor: 'nx:run-commands',
+                    options: {
+                        commands: ['tsx src/local-server.ts'],
+                        cwd: backendRoot,
+                    },
+                } });
             return config;
         });
         (0, devkit_1.generateFiles)(tree, (0, devkit_1.joinPathFragments)(__dirname, 'files', 'backend'), backendRoot, enhancedOptions, {
@@ -81,7 +88,9 @@ function trpcBackendGenerator(tree, options) {
             '@aws-lambda-powertools/metrics',
             '@aws-lambda-powertools/tracer',
             '@trpc/server',
-        ]), (0, versions_1.withVersions)(['@types/aws-lambda']));
+            'aws4fetch',
+            '@aws-sdk/credential-providers',
+        ]), (0, versions_1.withVersions)(['@types/aws-lambda', 'tsx']));
         tree.delete((0, devkit_1.joinPathFragments)(backendRoot, 'package.json'));
         tree.delete((0, devkit_1.joinPathFragments)(schemaRoot, 'package.json'));
         yield (0, format_1.formatFilesInSubtree)(tree);