@phila/cli 0.0.1

package/dist/templates/_shared/webapp-frontend/nuxt.config.ts

@@ -0,0 +1,25 @@
+// ABOUTME: Nuxt 3 configuration for Static Site Generation
+// ABOUTME: Outputs static files to dist/ for S3/CloudFront deployment
+
+export default defineNuxtConfig({
+  // Enable SSR for static generation
+  ssr: true,
+
+  // Static site generation preset
+  nitro: {
+    preset: 'static',
+    output: {
+      publicDir: 'dist',
+    },
+  },
+
+  // TypeScript support
+  typescript: {
+    strict: true,
+  },
+
+  // Disable telemetry
+  telemetry: false,
+
+  compatibilityDate: '2025-01-01',
+});

package/dist/templates/_shared/webapp-frontend/package.json.tmpl

@@ -0,0 +1,19 @@
+{
+  "name": "{{appName}}-frontend",
+  "version": "0.0.1",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "build": "nuxt generate",
+    "dev": "nuxt dev",
+    "preview": "nuxt preview",
+    "postinstall": "nuxt prepare"
+  },
+  "dependencies": {
+    "vue": "^3.5.13"
+  },
+  "devDependencies": {
+    "nuxt": "^3.14.0",
+    "typescript": "^5.7.0"
+  }
+}

package/dist/templates/_shared/webapp-frontend/pages/index.vue

@@ -0,0 +1,7 @@
+<template>
+  <div>
+    <h1>Welcome</h1>
+    <p>Your web application is ready. Edit this page in pages/index.vue.</p>
+    <p>API endpoint: <code>/api</code></p>
+  </div>
+</template>

package/dist/templates/_shared/webapp-frontend/tsconfig.json

@@ -0,0 +1,3 @@
+{
+  "extends": "./.nuxt/tsconfig.json"
+}

package/dist/templates/lambda-api-nodejs/README.md.tmpl

@@ -0,0 +1,203 @@
+# {{appName}}
+
+Lambda API application using Philadelphia constructs and philaroute.
+
+Generated on {{timestamp}}
+
+## Architecture
+
+![Architecture Diagram](https://github.com/CityOfPhiladelphia/phila-ctl/blob/main/packages/constructs/docs/diagrams/lambda-api.drawio)
+
+View the [architecture diagram](https://github.com/CityOfPhiladelphia/phila-ctl/blob/main/packages/constructs/docs/diagrams/lambda-api.drawio) in draw.io or VS Code with the Draw.io extension.
+
+## Quick Start
+
+### Prerequisites
+
+- Node.js 20+
+- AWS CLI configured with SSO
+- AWS profile named `phila-{{appName}}`
+
+### Setup
+
+```bash
+# Install dependencies
+npm install
+
+# Build all packages
+npm run build
+```
+
+### Deployment
+
+```bash
+# Configure AWS profile
+export AWS_PROFILE=phila-{{appName}}
+
+# Deploy to dev environment
+city deploy dev
+
+# Deploy to test environment
+city deploy test
+
+# Deploy to production (requires confirmation)
+city deploy prod
+```
+
+### Development
+
+```bash
+# Build TypeScript
+npm run build
+
+# View CDK diff before deploying
+npm run diff
+
+# Synthesize CloudFormation template
+npm run synth
+```
+
+## Project Structure
+
+```
+.
+├── cdk/                    # CDK infrastructure code
+│   └── app.ts              # Main CDK application
+├── apps/                   # Lambda function code
+│   └── {{lambdaName}}/     # Lambda handler
+│       └── index.ts        # Handler implementation
+└── city.config.json        # City CLI configuration
+```
+
+## API Usage
+
+After deployment, the API URL is available in SSM Parameter Store:
+
+```bash
+aws ssm get-parameter --name "/dev/{{appName}}/api/main/url" --query Parameter.Value --output text
+```
+
+Or use the City CLI:
+
+```bash
+city config list --env dev
+```
+
+## Routing with philaroute
+
+This template uses [@phila/philaroute](https://www.npmjs.com/package/@phila/philaroute) for HTTP routing. Routes are defined using a composable pipeline pattern.
+
+### Defining Routes
+
+```typescript
+import { Router, http } from '@phila/philaroute';
+
+const router = Router({ cors: { 'Access-Control-Allow-Origin': '*' } });
+
+// Simple response
+const health = router.path('/health');
+health.get([
+  http.response({
+    statusCode: 200,
+    body: { status: 'healthy' },
+  }),
+]);
+
+// With request handling
+const items = router.path('/items/:id');
+items.get([
+  async (acc) => {
+    const id = acc.request?.params?.id;
+    // ... fetch item from database
+    return {
+      ...acc,
+      response: {
+        statusCode: 200,
+        body: { id, name: 'Example' },
+      },
+    };
+  },
+]);
+```
+
+### Pipeline Functions
+
+Each route handler is an array of pipeline functions. Each function receives an accumulator and returns a modified accumulator:
+
+```typescript
+type RestAccumulator = {
+  request?: {
+    params?: { [key: string]: string };  // Path and query parameters
+    body?: any;                           // Parsed request body
+    headers?: { [key: string]: string };  // Request headers
+  };
+  data?: { [key: string]: any };          // Shared data between pipeline steps
+  response: {
+    statusCode?: number;
+    headers?: { [key: string]: string };
+    body?: string | Record<string, any> | any[];
+  };
+};
+```
+
+### Composable Middleware
+
+Create reusable pipeline functions:
+
+```typescript
+const validateAuth = async (acc: RestAccumulator) => {
+  const token = acc.request?.headers?.authorization;
+  if (!token) {
+    return {
+      ...acc,
+      response: { statusCode: 401, body: { error: 'Unauthorized' } },
+    };
+  }
+  return { ...acc, data: { ...acc.data, userId: 'decoded-user-id' } };
+};
+
+// Use in routes
+items.post([validateAuth, createItem]);
+```
+
+## Environment Variables
+
+Lambda functions automatically receive:
+- `APP_NAME` - Application name ({{appName}})
+- `ENVIRONMENT` - Current environment (dev/test/prod)
+
+## Adding a Database
+
+To add a database to your API:
+
+1. Update to use a different template:
+   - `lambda-postgres-api` - For PostgreSQL database
+   - `lambda-dynamo-api` - For DynamoDB table
+
+2. Or manually update your CDK code to use composed constructs like `LambdaPostgresApi`
+
+## Resources Created
+
+This application creates:
+- **API Gateway REST API** - HTTP endpoint for your application
+- **Lambda Function** - Serverless compute for handling requests
+- **VPC Security Group** - Network security for Lambda
+- **IAM Role** - Permissions for Lambda execution
+- **SSM Parameters** - Resource discovery (API URL, Lambda ARN)
+- **CloudWatch Logs** - Application logs
+
+## Next Steps
+
+1. Define your routes in `apps/{{lambdaName}}/index.ts`
+2. Create pipeline functions for validation and business logic
+3. Add shared middleware for authentication, logging, etc.
+4. Write tests for your handlers
+5. Set up CI/CD pipeline
+
+## Support
+
+For issues or questions:
+- [Philadelphia Infrastructure Library Documentation](https://github.com/CityOfPhiladelphia/phila-ctl)
+- [philaroute Documentation](https://www.npmjs.com/package/@phila/philaroute)
+- [AWS CDK Documentation](https://docs.aws.amazon.com/cdk/)
+- [API Gateway Developer Guide](https://docs.aws.amazon.com/apigateway/)

package/dist/templates/lambda-api-nodejs/apps/__lambdaName__/index.ts

@@ -0,0 +1,89 @@
+// ABOUTME: Lambda API handler using philaroute HTTP router
+// ABOUTME: Provides REST endpoint scaffolding with optional database connection patterns
+
+/**
+ * HTTP routing using @phila/philaroute
+ * @see https://github.com/CityOfPhiladelphia/philaroute
+ *
+ * Database connections (when needed):
+ *
+ * PostgreSQL using @phila/db-postgres
+ * @see https://github.com/CityOfPhiladelphia/db-postgres
+ *
+ *   import { getPool } from '@phila/db-postgres';
+ *
+ *   const items = {
+ *     list: async (acc: RestAccumulator) => {
+ *       const pool = await getPool();
+ *       const result = await pool.query('SELECT * FROM items');
+ *       acc.data.items = result.rows;
+ *       return acc;
+ *     }
+ *   };
+ *
+ * Oracle using @phila/db-oracle
+ * @see https://github.com/CityOfPhiladelphia/db-oracle
+ *
+ *   import { getConnection } from '@phila/db-oracle';
+ *
+ *   const items = {
+ *     list: async (acc: RestAccumulator) => {
+ *       const conn = await getConnection();
+ *       const result = await conn.execute('SELECT * FROM items');
+ *       acc.data.items = result.rows;
+ *       return acc;
+ *     }
+ *   };
+ *
+ * Environment variables (DB_SECRET_ARN, DB_NAME) are set automatically
+ * by the CDK construct when a database is attached to the stack.
+ */
+
+import type { APIGWV1Payload } from '@phila/philaroute/dist/types';
+import type { RestAccumulator } from '@phila/philaroute/dist/types';
+import { Router, http, validate } from '@phila/philaroute';
+
+const router = Router({
+  cors: {
+    'Access-Control-Allow-Origin': '*',
+    'Access-Control-Allow-Method': 'GET,POST,PUT,DELETE,OPTIONS',
+    'Access-Control-Allow-Headers': 'Content-Type,Authorization',
+  },
+});
+
+const health = {
+  check: async (acc: RestAccumulator) => {
+    acc.data.status = 'healthy';
+    acc.data.timestamp = new Date().toISOString();
+    return acc;
+  },
+};
+
+const hello = {
+  greet: async (acc: RestAccumulator) => {
+    acc.data.message = `Hello, ${acc.data.valid.parameters.name}!`;
+    return acc;
+  },
+};
+
+const items = {
+  create: async (acc: RestAccumulator) => {
+    acc.data.item = { id: '123', ...acc.data.valid.body };
+    acc.data.message = 'Item created';
+    return acc;
+  },
+};
+
+// Route definitions
+// The router automatically responds with 200 and acc.data as body.
+// Use http.response({ statusCode }) only when overriding (e.g., 201 for POST).
+
+router.path('/health').get([health.check]);
+
+router.path('/hello').get([validate.parameters(['name']), hello.greet]);
+
+router
+  .path('/items')
+  .post([validate.body({ name: 'string' }), items.create, http.response({ statusCode: 201 })]);
+
+export const handler = async (event: APIGWV1Payload) => router.routeToPath(event);

package/dist/templates/lambda-api-nodejs/apps/__lambdaName__/package.json

@@ -0,0 +1,17 @@
+{
+  "name": "{{lambdaName}}",
+  "version": "1.0.0",
+  "description": "Lambda function handler",
+  "private": true,
+  "scripts": {
+    "build": "npx tsc",
+    "watch": "npx tsc -w"
+  },
+  "dependencies": {
+    "@phila/philaroute": "^1.0.12",
+    "@types/aws-lambda": "^8.10.0"
+  },
+  "devDependencies": {
+    "typescript": "^5.3.0"
+  }
+}

package/dist/templates/lambda-api-nodejs/apps/__lambdaName__/tsconfig.json

@@ -0,0 +1,8 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "outDir": "dist",
+    "rootDir": "."
+  },
+  "include": ["*.ts"]
+}

package/dist/templates/lambda-api-nodejs/cdk/app.ts.tmpl

@@ -0,0 +1,53 @@
+#!/usr/bin/env node
+import 'source-map-support/register';
+import { App, Aspects, Stack } from 'aws-cdk-lib';
+import { AwsSolutionsChecks, NIST80053R5Checks } from 'cdk-nag';
+import { LambdaApi, Confidentiality, Environment } from '@phila/constructs';
+
+const app = new App();
+
+// Environment is determined by CDK context
+const environment = app.node.tryGetContext('environment') as Environment;
+
+if (!environment) {
+  throw new Error('Environment must be specified via context. Use: cdk deploy -c environment=dev');
+}
+
+// Read compliance frameworks from context
+const compliance = app.node.tryGetContext('compliance');
+const complianceFrameworks = compliance ? compliance.split(',') : [];
+
+// Application context with governance metadata
+const context = {
+  appName: '{{appName}}',
+  environment,
+  department: '{{department}}',
+  team: '{{team}}',
+  contact: '{{contact}}',
+  compliance: complianceFrameworks,
+  confidentiality: Confidentiality.{{CONFIDENTIALITY}},
+};
+
+// Stack name follows pattern: {appName}-{environment}
+const stack = new Stack(app, '{{appName}}-' + environment, {
+  env: {
+    account: process.env.CDK_DEFAULT_ACCOUNT,
+    region: process.env.CDK_DEFAULT_REGION || 'us-east-1',
+  },
+  stackName: '{{appName}}-' + environment,
+});
+
+// Create the LambdaApi construct
+new LambdaApi(stack, '{{appName}}Api', {
+  ...context,
+  apiId: 'main',
+  runtime: 'nodejs20',
+  handler: 'index.handler',
+  codeDir: '../apps/{{lambdaName}}',
+});
+
+// Apply compliance checks
+Aspects.of(app).add(new NIST80053R5Checks({ verbose: true }));
+Aspects.of(app).add(new AwsSolutionsChecks({ verbose: true }));
+
+app.synth();

package/dist/templates/lambda-api-nodejs/cdk/cdk.json

@@ -0,0 +1,68 @@
+{
+  "app": "npx ts-node --prefer-ts-exts app.ts",
+  "watch": {
+    "include": ["**"],
+    "exclude": [
+      "README.md",
+      "cdk*.json",
+      "**/*.d.ts",
+      "**/*.js",
+      "tsconfig.json",
+      "package*.json",
+      "yarn.lock",
+      "node_modules",
+      "test"
+    ]
+  },
+  "context": {
+    "@aws-cdk/aws-lambda:recognizeLayerVersion": true,
+    "@aws-cdk/core:checkSecretUsage": true,
+    "@aws-cdk/core:target-partitions": ["aws", "aws-cn"],
+    "@aws-cdk-containers/ecs-service-extensions:enableDefaultLogDriver": true,
+    "@aws-cdk/aws-ec2:uniqueImdsv2TemplateName": true,
+    "@aws-cdk/aws-ecs:arnFormatIncludesClusterName": true,
+    "@aws-cdk/aws-iam:minimizePolicies": true,
+    "@aws-cdk/core:validateSnapshotRemovalPolicy": true,
+    "@aws-cdk/aws-codepipeline:crossAccountKeyAliasStackSafeResourceName": true,
+    "@aws-cdk/aws-s3:createDefaultLoggingPolicy": true,
+    "@aws-cdk/aws-sns-subscriptions:restrictSqsDescryption": true,
+    "@aws-cdk/aws-apigateway:disableCloudWatchRole": false,
+    "@aws-cdk/core:enablePartitionLiterals": true,
+    "@aws-cdk/aws-events:eventsTargetQueueSameAccount": true,
+    "@aws-cdk/aws-iam:standardizedServicePrincipals": true,
+    "@aws-cdk/aws-ecs:disableExplicitDeploymentControllerForCircuitBreaker": true,
+    "@aws-cdk/aws-iam:importedRoleStackSafeDefaultPolicyName": true,
+    "@aws-cdk/aws-s3:serverAccessLogsUseBucketPolicy": true,
+    "@aws-cdk/aws-route53-patters:useCertificate": true,
+    "@aws-cdk/customresources:installLatestAwsSdkDefault": false,
+    "@aws-cdk/aws-rds:databaseProxyUniqueResourceName": true,
+    "@aws-cdk/aws-codedeploy:removeAlarmsFromDeploymentGroup": true,
+    "@aws-cdk/aws-apigateway:authorizerChangeDeploymentLogicalId": true,
+    "@aws-cdk/aws-ec2:launchTemplateDefaultUserData": true,
+    "@aws-cdk/aws-secretsmanager:useAttachedSecretResourcePolicyForSecretTargetAttachments": true,
+    "@aws-cdk/aws-redshift:columnId": true,
+    "@aws-cdk/aws-stepfunctions-tasks:enableEmrServicePolicyV2": true,
+    "@aws-cdk/aws-ec2:restrictDefaultSecurityGroup": true,
+    "@aws-cdk/aws-apigateway:requestValidatorUniqueId": true,
+    "@aws-cdk/aws-kms:aliasNameRef": true,
+    "@aws-cdk/aws-autoscaling:generateLaunchTemplateInsteadOfLaunchConfig": true,
+    "@aws-cdk/core:includePrefixInUniqueNameGeneration": true,
+    "@aws-cdk/aws-efs:denyAnonymousAccess": true,
+    "@aws-cdk/aws-opensearchservice:enableOpensearchMultiAzWithStandby": true,
+    "@aws-cdk/aws-lambda-nodejs:useLatestRuntimeVersion": true,
+    "@aws-cdk/aws-efs:mountTargetOrderInsensitiveLogicalId": true,
+    "@aws-cdk/aws-rds:auroraClusterChangeScopeOfInstanceParameterGroupWithEachParameters": true,
+    "@aws-cdk/aws-appsync:useArnForSourceApiAssociationIdentifier": true,
+    "@aws-cdk/aws-rds:preventRenderingDeprecatedCredentials": true,
+    "@aws-cdk/aws-codepipeline-actions:useNewDefaultBranchForCodeCommitSource": true,
+    "@aws-cdk/aws-cloudwatch-actions:changeLambdaPermissionLogicalIdForLambdaAction": true,
+    "@aws-cdk/aws-codepipeline:crossAccountKeysDefaultValueToFalse": true,
+    "@aws-cdk/aws-codepipeline:defaultPipelineTypeToV2": true,
+    "@aws-cdk/aws-kms:reduceCrossAccountRegionPolicyScope": true,
+    "@aws-cdk/aws-eks:nodegroupNameAttribute": true,
+    "@aws-cdk/aws-ec2:ebsDefaultGp3Volume": true,
+    "@aws-cdk/aws-ecs:removeDefaultDeploymentAlarm": true,
+    "@aws-cdk/custom-resources:logApiResponseDataPropertyTrueDefault": false,
+    "@aws-cdk/aws-s3:keepNotificationInImportedBucket": false
+  }
+}

package/dist/templates/lambda-api-nodejs/cdk/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "cdk",
+  "version": "1.0.0",
+  "private": true,
+  "scripts": {
+    "build": "tsc",
+    "watch": "tsc -w",
+    "cdk": "cdk"
+  },
+  "dependencies": {
+    "@phila/constructs": "file:{{constructsPath}}",
+    "aws-cdk-lib": "^2.100.0",
+    "cdk-nag": "^2.28.0",
+    "constructs": "^10.0.0",
+    "source-map-support": "^0.5.21"
+  },
+  "devDependencies": {
+    "@types/node": "^20.10.0",
+    "aws-cdk": "^2.100.0",
+    "ts-node": "^10.9.0",
+    "typescript": "^5.3.0"
+  }
+}

package/dist/templates/lambda-api-nodejs/cdk/tsconfig.json

@@ -0,0 +1,9 @@
+{
+  "extends": "../tsconfig.json",
+  "compilerOptions": {
+    "outDir": "dist",
+    "rootDir": "."
+  },
+  "include": ["*.ts"],
+  "exclude": ["node_modules", "cdk.out"]
+}

package/dist/templates/lambda-api-nodejs/package.json.tmpl

@@ -0,0 +1,20 @@
+{
+  "name": "{{appName}}",
+  "version": "1.0.0",
+  "description": "Lambda API application using Philadelphia constructs",
+  "private": true,
+  "scripts": {
+    "build": "npm run build --workspaces",
+    "test": "npm test --workspaces",
+    "synth": "cd cdk && cdk synth",
+    "deploy": "cd cdk && cdk deploy",
+    "diff": "cd cdk && cdk diff"
+  },
+  "workspaces": [
+    "cdk",
+    "apps/*"
+  ],
+  "devDependencies": {
+    "typescript": "^5.3.0"
+  }
+}

package/dist/templates/lambda-api-nodejs/tsconfig.json

@@ -0,0 +1,27 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "commonjs",
+    "lib": ["ES2020"],
+    "declaration": true,
+    "strict": true,
+    "noImplicitAny": true,
+    "strictNullChecks": true,
+    "noImplicitThis": true,
+    "alwaysStrict": true,
+    "noUnusedLocals": false,
+    "noUnusedParameters": false,
+    "noImplicitReturns": true,
+    "noFallthroughCasesInSwitch": false,
+    "inlineSourceMap": true,
+    "inlineSources": true,
+    "experimentalDecorators": true,
+    "strictPropertyInitialization": false,
+    "typeRoots": ["./node_modules/@types"],
+    "skipLibCheck": true,
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true
+  },
+  "exclude": ["node_modules", "cdk.out"]
+}