@jaypie/mcp 0.2.8 → 0.2.9

package/dist/index.js

@@ -885,7 +885,7 @@ function listLlmProviders() {
     };
 }
 
-const BUILD_VERSION_STRING = "@jaypie/mcp@0.2.8"
+const BUILD_VERSION_STRING = "@jaypie/mcp@0.2.9#f022ac30"
     ;
 const __filename$1 = fileURLToPath(import.meta.url);
 const __dirname$1 = path.dirname(__filename$1);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jaypie/mcp",
-  "version": "0.2.8",
+  "version": "0.2.9",
   "description": "Jaypie MCP",
   "repository": {
     "type": "git",

package/prompts/Jaypie_CDK_Constructs_and_Patterns.md

@@ -102,54 +102,52 @@ Preconfigured with API-optimized timeouts and role tags.
 
 ### Streaming Lambda Functions
 
-Enable Lambda Response Streaming via Function URLs for real-time SSE responses:
+Use `JaypieStreamingLambda` for Express apps with AWS Lambda Web Adapter and streaming support:
 
 ```typescript
-import { FunctionUrlAuthType, InvokeMode } from "aws-cdk-lib/aws-lambda";
-
-const streamingLambda = new JaypieLambda(this, "StreamingFunction", {
-  code: "dist",
-  handler: "stream.handler",
-  timeout: Duration.minutes(5), // Longer timeout for streaming
+import { JaypieStreamingLambda, JaypieDistribution } from "@jaypie/constructs";
+
+// Create streaming Lambda with Web Adapter
+const streamingLambda = new JaypieStreamingLambda(this, "StreamingApi", {
+  code: "dist/api",
+  handler: "run.sh",           // Shell script to start Express app
+  streaming: true,             // Enables RESPONSE_STREAM invoke mode
+  port: 8000,                  // Port your app listens on (default: 8000)
 });
 
-// Add Function URL with streaming enabled
-const functionUrl = streamingLambda.addFunctionUrl({
-  authType: FunctionUrlAuthType.NONE,     // Public access
-  // authType: FunctionUrlAuthType.AWS_IAM, // IAM authentication
-  invokeMode: InvokeMode.RESPONSE_STREAM, // Enable streaming
-});
-
-// Output the URL
-new cdk.CfnOutput(this, "StreamingUrl", {
-  value: functionUrl.url,
+// CloudFront auto-detects invokeMode from JaypieStreamingLambda
+new JaypieDistribution(this, "Distribution", {
+  handler: streamingLambda,
+  host: "api.example.com",
+  zone: "example.com",
 });
 ```
 
 Features:
-- `RESPONSE_STREAM` invoke mode enables real-time streaming
-- Works with `lambdaStreamHandler` from `@jaypie/lambda`
-- Use `FunctionUrlAuthType.AWS_IAM` for authenticated endpoints
-- Combine with API Gateway for custom domains via `JaypieApiGateway`
+- Automatically adds AWS Lambda Web Adapter layer (supports ARM64 and x86_64)
+- Sets `AWS_LAMBDA_EXEC_WRAPPER` and `AWS_LWA_INVOKE_MODE` environment variables
+- Exposes `invokeMode` property for auto-detection by `JaypieDistribution`
+- Use `streaming: false` for buffered mode (traditional Lambda behavior)
 
-For Express-based streaming with custom domains:
+For direct Function URL access (bypass CloudFront):
 ```typescript
-// Express app with streaming routes
-const expressLambda = new JaypieExpressLambda(this, "ExpressStream", {
+import { FunctionUrlAuthType, InvokeMode } from "aws-cdk-lib/aws-lambda";
+
+const streamingLambda = new JaypieLambda(this, "StreamingFunction", {
   code: "dist",
-  handler: "app.handler",
+  handler: "stream.handler",
   timeout: Duration.minutes(5),
 });
 
-// API Gateway handles the domain routing
-new JaypieApiGateway(this, "Api", {
-  handler: expressLambda,
-  host: "api.example.com",
-  zone: "example.com",
+const functionUrl = streamingLambda.addFunctionUrl({
+  authType: FunctionUrlAuthType.NONE,
+  invokeMode: InvokeMode.RESPONSE_STREAM,
 });
+
+new cdk.CfnOutput(this, "StreamingUrl", { value: functionUrl.url });
 ```
 
-Note: API Gateway has a 29-second timeout limit. For longer streaming operations, use Function URLs directly.
+Note: API Gateway has a 29-second timeout limit. For longer streaming operations, use Function URLs or CloudFront with Lambda Function URLs.
 
 ### Stack Types
 

package/prompts/Jaypie_DynamoDB_Package.md

@@ -430,6 +430,99 @@ try {
 }
 ```
 
+## Seed and Export Utilities
+
+Idempotent seeding and data export for migrations and bootstrapping.
+
+### seedEntityIfNotExists
+
+Seed a single entity if it doesn't already exist (checked by alias):
+
+```typescript
+import { APEX, seedEntityIfNotExists } from "@jaypie/dynamodb";
+
+const created = await seedEntityIfNotExists({
+  alias: "config-main",
+  model: "config",
+  name: "Main Configuration",
+  ou: APEX,
+});
+// Returns true if created, false if already exists
+```
+
+### seedEntities
+
+Seed multiple entities with idempotency:
+
+```typescript
+import { APEX, seedEntities } from "@jaypie/dynamodb";
+
+const result = await seedEntities([
+  { alias: "vocab-en", model: "vocabulary", name: "English", ou: APEX },
+  { alias: "vocab-es", model: "vocabulary", name: "Spanish", ou: APEX },
+]);
+// result.created: aliases of created entities
+// result.skipped: aliases of entities that already existed
+// result.errors: { alias, error } for failed operations
+
+// Dry run (preview without writing)
+const preview = await seedEntities(entities, { dryRun: true });
+
+// Replace existing entities
+await seedEntities(entities, { replace: true });
+```
+
+Auto-generates `id` (UUID), `createdAt`, `updatedAt`, and `sequence` if missing.
+
+### exportEntities
+
+Export entities by model and organizational unit:
+
+```typescript
+import { APEX, exportEntities } from "@jaypie/dynamodb";
+
+const { entities, count } = await exportEntities("vocabulary", APEX);
+// entities: FabricEntity[] sorted by sequence ascending
+// count: number of entities
+
+// With limit
+const { entities: limited } = await exportEntities("vocabulary", APEX, 100);
+```
+
+### exportEntitiesToJson
+
+Export as JSON string:
+
+```typescript
+import { APEX, exportEntitiesToJson } from "@jaypie/dynamodb";
+
+const json = await exportEntitiesToJson("vocabulary", APEX);
+// Pretty printed by default
+
+const compact = await exportEntitiesToJson("vocabulary", APEX, false);
+// Compact JSON
+```
+
+### SeedResult Interface
+
+```typescript
+interface SeedResult {
+  created: string[];   // Aliases of created entities
+  skipped: string[];   // Aliases of skipped entities (already exist)
+  errors: Array<{ alias: string; error: string }>;
+}
+
+interface SeedOptions {
+  replace?: boolean;   // Overwrite existing (default: false)
+  dryRun?: boolean;    // Preview without writing (default: false)
+}
+
+interface ExportResult<T extends FabricEntity = FabricEntity> {
+  entities: T[];       // Exported entities
+  count: number;       // Number of entities
+}
+```
+
 ## Testing
 
 Mock implementations in `@jaypie/testkit`:
@@ -445,9 +538,17 @@ vi.mock("@jaypie/dynamodb", async () => {
 // Key builders and indexEntity work correctly (delegate to real implementations)
 // Query functions return empty results by default
 // Entity operations return sensible defaults
+// Seed functions return { created: [], skipped: [], errors: [] } by default
+// Export functions return { entities: [], count: 0 } by default
 
 // Customize mock behavior:
-import { queryByOu, getEntity, putEntity } from "@jaypie/testkit/mock";
+import {
+  exportEntities,
+  getEntity,
+  putEntity,
+  queryByOu,
+  seedEntities,
+} from "@jaypie/testkit/mock";
 
 queryByOu.mockResolvedValue({
   items: [{ id: "123", name: "Test" }],
@@ -455,6 +556,17 @@ queryByOu.mockResolvedValue({
 });
 
 getEntity.mockResolvedValue({ id: "123", model: "record", name: "Test" });
+
+seedEntities.mockResolvedValue({
+  created: ["entity-1", "entity-2"],
+  skipped: [],
+  errors: [],
+});
+
+exportEntities.mockResolvedValue({
+  entities: [{ id: "123", model: "record" }],
+  count: 1,
+});
 ```
 
 ## Best Practices

package/prompts/Jaypie_Express_Package.md

@@ -407,6 +407,50 @@ expressHandler automatically sets these headers:
 
 When Datadog environment variables are configured, expressHandler automatically submits metrics for each request including status code and path.
 
+## Server Creation
+
+Use `createServer` to quickly set up an Express server with standard Jaypie middleware.
+
+### Basic Server Usage
+
+```typescript
+import express from "express";
+import { createServer, expressHandler } from "jaypie";
+
+const app = express();
+
+app.get("/", expressHandler(async (req, res) => {
+  return { message: "Hello World" };
+}));
+
+const { server, port } = await createServer(app);
+console.log(`Server running on port ${port}`);
+```
+
+### Server Options
+
+```typescript
+import { createServer } from "jaypie";
+import type { CreateServerOptions } from "jaypie";
+
+const options: CreateServerOptions = {
+  port: 3000,              // Port to listen on (default: PORT env var or 8080)
+  cors: { origin: "*" },   // CORS config (false to disable)
+  jsonLimit: "10mb",       // JSON body parser limit (default: "1mb")
+  middleware: [myMiddleware], // Additional middleware to apply
+};
+
+const { server, port } = await createServer(app, options);
+```
+
+### Server Result
+
+```typescript
+import type { ServerResult } from "jaypie";
+
+// { server: Server, port: number }
+```
+
 ## Streaming Responses
 
 Use `expressStreamHandler` for Server-Sent Events (SSE) streaming responses. Ideal for real-time updates, LLM streaming, and long-running operations.
@@ -497,3 +541,33 @@ import type {
   JaypieStreamHandlerValidate,
 } from "jaypie";
 ```
+
+## Invoke UUID Detection
+
+Use `getCurrentInvokeUuid` to get the current request ID. Automatically detects the environment (Lambda, Lambda Web Adapter, or local development).
+
+### Basic Usage
+
+```typescript
+import { getCurrentInvokeUuid } from "jaypie";
+
+const handler = expressHandler(async (req, res) => {
+  const invokeUuid = getCurrentInvokeUuid(req);
+  // Returns AWS request ID in Lambda, or generates a local UUID
+  return { requestId: invokeUuid };
+});
+```
+
+### Environment Detection
+
+The function adapts to different runtime environments:
+
+1. **Lambda (native)**: Uses `awsRequestId` from Lambda context
+2. **Lambda Web Adapter**: Extracts from `x-amzn-request-id` header or `_X_AMZN_TRACE_ID` env var
+3. **Local development**: Generates a UUID for consistent tracing
+
+### Lambda Web Adapter Headers
+
+When running Express behind AWS Lambda Web Adapter, the function extracts the request ID from:
+- `x-amzn-request-id` header (set by Lambda Web Adapter)
+- `_X_AMZN_TRACE_ID` environment variable (X-Ray trace ID, set by Lambda runtime)