@aws/nx-plugin 0.0.0

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

@@ -0,0 +1,146 @@
+import { Logger } from '@aws-lambda-powertools/logger';
+import { Metrics, MetricUnit } from '@aws-lambda-powertools/metrics';
+import { Tracer } from '@aws-lambda-powertools/tracer';
+import { initTRPC, TRPCError } from '@trpc/server';
+import { Context as APIGWContext } from 'aws-lambda';
+import { Subsegment } from 'aws-xray-sdk-core';
+
+export type IMiddlewareContext = ILoggerContext &
+  IMetricsContext &
+  ITracerContext;
+
+interface ILoggerContext extends APIGWContext {
+  logger: Logger;
+}
+
+interface IMetricsContext extends APIGWContext {
+  metrics: Metrics;
+}
+
+interface ITracerContext extends APIGWContext {
+  tracer: Tracer;
+}
+
+export const createLoggerPlugin = () => {
+  const t = initTRPC.context<ILoggerContext>().create();
+  return {
+    loggerPlugin: 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;
+    }),
+  };
+};
+
+export const createMetricsPlugin = () => {
+  const t = initTRPC.context<IMetricsContext>().create();
+
+  return {
+    metricsPlugin: 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();
+      }
+    }),
+  };
+};
+
+export const createTracerPlugin = () => {
+  const t = initTRPC.context<ITracerContext>().create();
+
+  return {
+    tracerPlugin: 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);
+        }
+      }
+    }),
+  };
+};
+
+export const createErrorPlugin = () => {
+  const t = initTRPC.context().create();
+  return {
+    errorPlugin: t.procedure.use(async (opts) => {
+      const response = await opts.next({
+        ctx: {
+          ...opts.ctx,
+        },
+      });
+
+      if (!response.ok) {
+        let trpcError: TRPCError;
+
+        if (response.error.cause instanceof TRPCError) {
+          trpcError = response.error.cause;
+        } else {
+          trpcError = new TRPCError({
+            code: 'INTERNAL_SERVER_ERROR',
+            message: 'An unexpected error occurred, please try again later.',
+            cause: response.error.cause,
+          });
+        }
+
+        throw trpcError;
+      } else {
+        return response;
+      }
+    }),
+  };
+};

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

@@ -0,0 +1,36 @@
+import { initTRPC } from '@trpc/server';
+import {
+  awsLambdaRequestHandler,
+} from '@trpc/server/adapters/aws-lambda';
+import { EchoSchema } from '<%= schemaProjectAlias %>';
+import {
+  createErrorPlugin,
+  createLoggerPlugin,
+  createMetricsPlugin,
+  createTracerPlugin,
+  IMiddlewareContext,
+} from './middleware.js';
+import { z } from 'zod';
+
+export type Context = IMiddlewareContext;
+
+const t = initTRPC.context<Context>().create();
+export const router = t.router;
+export const publicProcedure = t.procedure
+.unstable_concat(createLoggerPlugin().loggerPlugin)
+.unstable_concat(createTracerPlugin().tracerPlugin)
+.unstable_concat(createMetricsPlugin().metricsPlugin)
+.unstable_concat(createErrorPlugin().errorPlugin);;
+
+const appRouter = router({
+  echo: publicProcedure
+    .input(z.string())
+    .output(EchoSchema)
+    .query((opts) => ({ result: opts.input })),
+});
+
+export const handler = awsLambdaRequestHandler({
+  router: appRouter
+});
+
+export type AppRouter = typeof appRouter;

package/src/trpc/backend/files/common/constructs/src/__apiNameKebabCase__/index.ts.template

@@ -0,0 +1,64 @@
+import { Construct } from 'constructs';
+import { Runtime, RuntimeFamily } from 'aws-cdk-lib/aws-lambda';
+import { CfnOutput, Duration } from 'aws-cdk-lib';
+import * as url from 'url';
+import { CorsHttpMethod, HttpApi, HttpMethod, IHttpRouteAuthorizer } from 'aws-cdk-lib/aws-apigatewayv2';
+import { HttpLambdaIntegration } from 'aws-cdk-lib/aws-apigatewayv2-integrations';
+import { NodejsFunction } from 'aws-cdk-lib/aws-lambda-nodejs';
+import { Effect, IRole, PolicyStatement } from 'aws-cdk-lib/aws-iam';
+import { RuntimeConfig } from '../runtime-config/index.js';
+
+export interface <%= apiNameClassName %>Props {
+    readonly defaultAuthorizer: IHttpRouteAuthorizer;
+    readonly allowedOrigins?: string[];
+};
+
+
+export class <%= apiNameClassName %> extends Construct {
+    public readonly api: HttpApi;
+
+    constructor(scope: Construct, id: string, props: <%= apiNameClassName %>Props) {
+        super(scope, id);
+
+        const routerFunction = new NodejsFunction(this, '<%= apiNameClassName %>Handler', {
+            timeout: Duration.seconds(30),
+            runtime: new Runtime('nodejs20.x', RuntimeFamily.NODEJS),
+            handler: 'handler',
+            entry: url.fileURLToPath(new URL('../../<%= relativePathToProjectRoot %>/backend/src/lambdas/router.ts', import.meta.url)),
+            environment: {
+                'AWS_CONNECTION_REUSE_ENABLED': '1'
+            }
+        });
+
+        this.api = new HttpApi(this, '<%= apiNameClassName %>', {
+            corsPreflight: {
+                allowOrigins: props.allowedOrigins ?? ['*'],
+                allowMethods: [CorsHttpMethod.ANY],
+                allowHeaders: ['authorization', 'content-type', 'x-amz-content-sha256', 'x-amz-date', 'x-amz-security-token'],
+            },
+            defaultAuthorizer: props.defaultAuthorizer,
+        });
+
+        this.api.addRoutes({
+            path: '/{proxy+}',
+            methods: [HttpMethod.GET, HttpMethod.DELETE, HttpMethod.POST, HttpMethod.PUT, HttpMethod.PATCH, HttpMethod.HEAD],
+            integration: new HttpLambdaIntegration('RouterIntegration', routerFunction),
+        });
+
+        new CfnOutput(this, '<%= apiNameClassName %>Url', { value: this.api.url! });
+
+        RuntimeConfig.ensure(this).config.trpcApis = {
+            '<%= apiName %>': this.api.url!
+        };
+    }
+
+    public grantInvokeAccess(role: IRole) {
+      role.addToPrincipalPolicy(
+        new PolicyStatement({
+          effect: Effect.ALLOW,
+          actions: ['execute-api:Invoke'],
+          resources: [this.api.arnForExecuteApi('*', '/*', '*')],
+        })
+      );
+  }
+}

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

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

package/src/trpc/backend/generator.d.ts

@@ -0,0 +1,4 @@
+import { Tree } from '@nx/devkit';
+import { TrpcBackendGeneratorSchema } from './schema';
+export declare function trpcBackendGenerator(tree: Tree, options: TrpcBackendGeneratorSchema): Promise<() => void>;
+export default trpcBackendGenerator;

package/src/trpc/backend/generator.js

@@ -0,0 +1,128 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    default: function() {
+        return _default;
+    },
+    trpcBackendGenerator: function() {
+        return trpcBackendGenerator;
+    }
+});
+const _extends = require("@swc/helpers/_/_extends");
+const _interop_require_default = require("@swc/helpers/_/_interop_require_default");
+const _devkit = require("@nx/devkit");
+const _lodashkebabcase = /*#__PURE__*/ _interop_require_default._(require("lodash.kebabcase"));
+const _sharedconstructs = require("../../utils/shared-constructs");
+const _typescript = require("typescript");
+const _tsquery = require("@phenomnomnominal/tsquery");
+const _generator = /*#__PURE__*/ _interop_require_default._(require("../../ts/lib/generator"));
+const _npmscope = require("../../utils/npm-scope");
+const _versions = require("../../utils/versions");
+const _paths = require("../../utils/paths");
+const toClassName = (str)=>{
+    const words = str.replace(/[^a-zA-Z0-9]/g, ' ').split(/\s+/);
+    return words.map((word, index)=>{
+        if (index === 0 && /^\d/.test(word)) {
+            return '_' + word;
+        }
+        return word.charAt(0).toUpperCase() + word.slice(1);
+    }).join('');
+};
+async function trpcBackendGenerator(tree, options) {
+    await (0, _sharedconstructs.sharedConstructsGenerator)(tree);
+    const apiNameKebabCase = (0, _lodashkebabcase.default)(options.apiName);
+    const apiNameClassName = toClassName(options.apiName);
+    var _options_directory;
+    const projectRoot = (0, _devkit.joinPathFragments)((_options_directory = options.directory) != null ? _options_directory : '.', apiNameKebabCase);
+    const relativePathToProjectRoot = `${(0, _devkit.joinPathFragments)((0, _paths.getRelativePathToRoot)(tree, `${(0, _npmscope.getNpmScopePrefix)(tree)}common-constructs`), projectRoot)}`;
+    const schemaRoot = (0, _devkit.joinPathFragments)(projectRoot, 'schema');
+    const backendRoot = (0, _devkit.joinPathFragments)(projectRoot, 'backend');
+    const backendName = `${apiNameKebabCase}-backend`;
+    const schemaName = `${apiNameKebabCase}-schema`;
+    const backendProjectName = `${options.apiNamespace}/${backendName}`;
+    const schemaProjectName = `${options.apiNamespace}/${schemaName}`;
+    const enhancedOptions = _extends._({
+        backendProjectName,
+        backendProjectAlias: (0, _npmscope.toScopeAlias)(backendProjectName),
+        schemaProjectName,
+        schemaProjectAlias: (0, _npmscope.toScopeAlias)(schemaProjectName),
+        apiNameKebabCase,
+        apiNameClassName,
+        relativePathToProjectRoot
+    }, options);
+    await (0, _generator.default)(tree, {
+        scope: options.apiNamespace,
+        name: backendName,
+        directory: projectRoot,
+        subDirectory: 'backend',
+        unitTestRunner: options.unitTestRunner
+    });
+    await (0, _generator.default)(tree, {
+        scope: options.apiNamespace,
+        name: schemaName,
+        directory: projectRoot,
+        subDirectory: 'schema',
+        unitTestRunner: options.unitTestRunner
+    });
+    const constructsPath = (0, _devkit.joinPathFragments)(_sharedconstructs.PACKAGES_DIR, _sharedconstructs.SHARED_CONSTRUCTS_DIR, 'src', apiNameKebabCase, 'index.ts');
+    if (!tree.exists(constructsPath)) {
+        (0, _devkit.generateFiles)(tree, (0, _devkit.joinPathFragments)(__dirname, 'files', _sharedconstructs.SHARED_CONSTRUCTS_DIR), (0, _devkit.joinPathFragments)(_sharedconstructs.PACKAGES_DIR, _sharedconstructs.SHARED_CONSTRUCTS_DIR), enhancedOptions);
+        (0, _devkit.addDependenciesToPackageJson)(tree, (0, _versions.withVersions)([
+            'constructs',
+            'aws-cdk-lib'
+        ]), {});
+        const sharedConstructsIndexTsPath = (0, _devkit.joinPathFragments)(_sharedconstructs.PACKAGES_DIR, _sharedconstructs.SHARED_CONSTRUCTS_DIR, 'src', 'index.ts');
+        const sharedConstructsIndexContents = tree.read(sharedConstructsIndexTsPath).toString();
+        const apiExportDeclaration = _typescript.factory.createExportDeclaration(undefined, undefined, undefined, _typescript.factory.createStringLiteral(`./${apiNameKebabCase}/index.js`));
+        const updatedIndex = _tsquery.tsquery.map((0, _tsquery.ast)(sharedConstructsIndexContents), 'SourceFile', (node)=>{
+            return _extends._({}, node, {
+                statements: [
+                    apiExportDeclaration,
+                    ...node.statements
+                ]
+            });
+        }).getFullText();
+        if (sharedConstructsIndexContents !== updatedIndex) {
+            tree.write(sharedConstructsIndexTsPath, updatedIndex);
+        }
+    }
+    (0, _devkit.updateJson)(tree, (0, _devkit.joinPathFragments)(backendRoot, 'project.json'), (config)=>{
+        config.metadata = {
+            apiName: options.apiName
+        };
+        return config;
+    });
+    (0, _devkit.generateFiles)(tree, (0, _devkit.joinPathFragments)(__dirname, 'files', 'backend'), backendRoot, enhancedOptions);
+    (0, _devkit.generateFiles)(tree, (0, _devkit.joinPathFragments)(__dirname, 'files', 'schema'), schemaRoot, enhancedOptions);
+    tree.delete((0, _devkit.joinPathFragments)(backendRoot, 'src', 'lib'));
+    tree.delete((0, _devkit.joinPathFragments)(schemaRoot, 'src', 'lib'));
+    (0, _devkit.addDependenciesToPackageJson)(tree, (0, _versions.withVersions)([
+        'zod',
+        '@trpc/server',
+        'aws-xray-sdk-core',
+        'aws-cdk-lib',
+        'constructs',
+        '@aws-lambda-powertools/logger',
+        '@aws-lambda-powertools/metrics',
+        '@aws-lambda-powertools/tracer'
+    ]), (0, _versions.withVersions)([
+        '@types/aws-lambda'
+    ]));
+    tree.delete((0, _devkit.joinPathFragments)(backendRoot, 'package.json'));
+    tree.delete((0, _devkit.joinPathFragments)(schemaRoot, 'package.json'));
+    await (0, _devkit.formatFiles)(tree);
+    return ()=>{
+        (0, _devkit.installPackagesTask)(tree);
+    };
+}
+const _default = trpcBackendGenerator;
+
+//# sourceMappingURL=generator.js.map

package/src/trpc/backend/generator.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../packages/nx-plugin/src/trpc/backend/generator.ts"],"sourcesContent":["import {\n  addDependenciesToPackageJson,\n  formatFiles,\n  generateFiles,\n  installPackagesTask,\n  joinPathFragments,\n  ProjectConfiguration,\n  Tree,\n  updateJson,\n} from '@nx/devkit';\nimport { TrpcBackendGeneratorSchema } from './schema';\nimport kebabCase from 'lodash.kebabcase';\nimport {\n  PACKAGES_DIR,\n  SHARED_CONSTRUCTS_DIR,\n  sharedConstructsGenerator,\n} from '../../utils/shared-constructs';\nimport { factory, SourceFile } from 'typescript';\nimport { ast, tsquery } from '@phenomnomnominal/tsquery';\nimport tsLibGenerator from '../../ts/lib/generator';\nimport { getNpmScopePrefix, toScopeAlias } from '../../utils/npm-scope';\nimport { withVersions } from '../../utils/versions';\nimport { getRelativePathToRoot } from '../../utils/paths';\n\nconst toClassName = (str: string): string => {\n  const words = str.replace(/[^a-zA-Z0-9]/g, ' ').split(/\\s+/);\n\n  return words\n    .map((word, index) => {\n      if (index === 0 && /^\\d/.test(word)) {\n        return '_' + word;\n      }\n      return word.charAt(0).toUpperCase() + word.slice(1);\n    })\n    .join('');\n};\n\nexport async function trpcBackendGenerator(\n  tree: Tree,\n  options: TrpcBackendGeneratorSchema\n) {\n  await sharedConstructsGenerator(tree);\n\n  const apiNameKebabCase = kebabCase(options.apiName);\n  const apiNameClassName = toClassName(options.apiName);\n  const projectRoot = joinPathFragments(options.directory ?? '.', apiNameKebabCase);\n  const relativePathToProjectRoot = `${joinPathFragments(getRelativePathToRoot(tree, `${getNpmScopePrefix(tree)}common-constructs`), projectRoot)}`;\n  const schemaRoot = joinPathFragments(projectRoot, 'schema');\n  const backendRoot = joinPathFragments(projectRoot, 'backend');\n\n  const backendName = `${apiNameKebabCase}-backend`;\n  const schemaName = `${apiNameKebabCase}-schema`;\n\n  const backendProjectName = `${options.apiNamespace}/${backendName}`;\n  const schemaProjectName = `${options.apiNamespace}/${schemaName}`;\n  const enhancedOptions = {\n    backendProjectName,\n    backendProjectAlias: toScopeAlias(backendProjectName),\n    schemaProjectName,\n    schemaProjectAlias: toScopeAlias(schemaProjectName),\n    apiNameKebabCase,\n    apiNameClassName,\n    relativePathToProjectRoot,\n    ...options,\n  };\n\n  await tsLibGenerator(tree, {\n    scope: options.apiNamespace,\n    name: backendName,\n    directory: projectRoot,\n    subDirectory: 'backend',\n    unitTestRunner: options.unitTestRunner,\n  });\n\n  await tsLibGenerator(tree, {\n    scope: options.apiNamespace,\n    name: schemaName,\n    directory: projectRoot,\n    subDirectory: 'schema',\n    unitTestRunner: options.unitTestRunner,\n  });\n\n  const constructsPath = joinPathFragments(PACKAGES_DIR, SHARED_CONSTRUCTS_DIR, 'src', apiNameKebabCase, 'index.ts');\n  \n  if (!tree.exists(constructsPath)) {\n    generateFiles(\n      tree,\n      joinPathFragments(__dirname, 'files', SHARED_CONSTRUCTS_DIR),\n      joinPathFragments(PACKAGES_DIR, SHARED_CONSTRUCTS_DIR),\n      enhancedOptions\n    );\n\n    addDependenciesToPackageJson(\n      tree,\n      withVersions(['constructs', 'aws-cdk-lib']),\n      {}\n    );\n\n    const sharedConstructsIndexTsPath = joinPathFragments(\n      PACKAGES_DIR,\n      SHARED_CONSTRUCTS_DIR,\n      'src',\n      'index.ts'\n    );\n    const sharedConstructsIndexContents = tree\n      .read(sharedConstructsIndexTsPath)\n      .toString();\n\n    const apiExportDeclaration = factory.createExportDeclaration(\n      undefined,\n      undefined,\n      undefined,\n      factory.createStringLiteral(`./${apiNameKebabCase}/index.js`)\n    );\n    const updatedIndex = tsquery\n      .map(\n        ast(sharedConstructsIndexContents),\n        'SourceFile',\n        (node: SourceFile) => {\n          return {\n            ...node,\n            statements: [apiExportDeclaration, ...node.statements],\n          };\n        }\n      )\n      .getFullText();\n\n    if (sharedConstructsIndexContents !== updatedIndex) {\n      tree.write(sharedConstructsIndexTsPath, updatedIndex);\n    }\n  }\n\n  updateJson(\n    tree,\n    joinPathFragments(backendRoot, 'project.json'),\n    (config: ProjectConfiguration) => {\n      config.metadata = {\n        apiName: options.apiName,\n      } as unknown;\n\n      return config;\n    }\n  );\n\n  generateFiles(\n    tree,\n    joinPathFragments(__dirname, 'files', 'backend'),\n    backendRoot,\n    enhancedOptions\n  );\n  generateFiles(\n    tree,\n    joinPathFragments(__dirname, 'files', 'schema'),\n    schemaRoot,\n    enhancedOptions\n  );\n\n  tree.delete(joinPathFragments(backendRoot, 'src', 'lib'));\n  tree.delete(joinPathFragments(schemaRoot, 'src', 'lib'));\n\n  addDependenciesToPackageJson(\n    tree,\n    withVersions([\n      'zod',\n      '@trpc/server',\n      'aws-xray-sdk-core',\n      'aws-cdk-lib',\n      'constructs',\n      '@aws-lambda-powertools/logger',\n      '@aws-lambda-powertools/metrics',\n      '@aws-lambda-powertools/tracer',\n    ]),\n    withVersions(['@types/aws-lambda'])\n  );\n\n  tree.delete(joinPathFragments(backendRoot, 'package.json'));\n  tree.delete(joinPathFragments(schemaRoot, 'package.json'));\n\n  await formatFiles(tree);\n\n  return () => {\n    installPackagesTask(tree);\n  };\n}\n\nexport default trpcBackendGenerator;\n"],"names":["trpcBackendGenerator","toClassName","str","words","replace","split","map","word","index","test","charAt","toUpperCase","slice","join","tree","options","sharedConstructsGenerator","apiNameKebabCase","kebabCase","apiName","apiNameClassName","projectRoot","joinPathFragments","directory","relativePathToProjectRoot","getRelativePathToRoot","getNpmScopePrefix","schemaRoot","backendRoot","backendName","schemaName","backendProjectName","apiNamespace","schemaProjectName","enhancedOptions","backendProjectAlias","toScopeAlias","schemaProjectAlias","tsLibGenerator","scope","name","subDirectory","unitTestRunner","constructsPath","PACKAGES_DIR","SHARED_CONSTRUCTS_DIR","exists","generateFiles","__dirname","addDependenciesToPackageJson","withVersions","sharedConstructsIndexTsPath","sharedConstructsIndexContents","read","toString","apiExportDeclaration","factory","createExportDeclaration","undefined","createStringLiteral","updatedIndex","tsquery","ast","node","statements","getFullText","write","updateJson","config","metadata","delete","formatFiles","installPackagesTask"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"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"}

package/src/trpc/backend/schema.d.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+
+//# sourceMappingURL=schema.d.js.map

package/src/trpc/backend/schema.d.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../packages/nx-plugin/src/trpc/backend/schema.d.ts"],"names":[],"rangeMappings":"","mappings":""}

package/src/trpc/backend/schema.d.ts

@@ -0,0 +1,8 @@
+
+export interface TrpcBackendGeneratorSchema {
+  apiName: string;
+  apiNamespace: string;
+  bundler: TsLibGeneratorSchema['bundler'];
+  directory?: TsLibGeneratorSchema['directory'];
+  unitTestRunner: TsLibGeneratorSchema['unitTestRunner'];
+}

package/src/trpc/backend/schema.json

@@ -0,0 +1,44 @@
+{
+  "$schema": "https://json-schema.org/schema",
+  "$id": "TrpcBackend",
+  "title": "",
+  "type": "object",
+  "properties": {
+    "apiName": {
+      "type": "string",
+      "description": "",
+      "$default": {
+        "$source": "argv",
+        "index": 0
+      },
+      "x-prompt": "What name would your API to be? i.e: MyApi"
+    },
+    "apiNamespace": {
+      "type": "string",
+      "description": "",
+      "$default": {
+        "$source": "argv",
+        "index": 0
+      },
+      "pattern": "^@[a-z0-9-]+(?:/[a-z0-9-]+)?$",
+      "x-prompt": "What namespace would you like your API to have? i.e: @myapi"
+    },
+    "directory": {
+      "description": "The directory of the new application.",
+      "type": "string",
+      "alias": "dir",
+      "x-priority": "important",
+      "default": "packages",
+      "x-prompt": "What directory would you like to store your application in?"
+    },
+    "unitTestRunner": {
+      "type": "string",
+      "enum": ["jest", "vitest", "none"],
+      "description": "Test runner to use for unit tests.",
+      "x-prompt": "Which unit test runner would you like to use?",
+      "default": "vitest",
+      "x-priority": "important"
+    }
+  },
+  "required": ["apiName", "apiNamespace"]
+}