@mettlecast/domain-cdk-packer 0.2.1 → 0.2.4

package/dist/constructs/health-construct.js

@@ -2,6 +2,8 @@ import * as cdk from 'aws-cdk-lib';
 import * as lambda from 'aws-cdk-lib/aws-lambda';
 import * as nodejs from 'aws-cdk-lib/aws-lambda-nodejs';
 import { Construct } from 'constructs';
+import { createRequire } from 'module';
+const require = createRequire(import.meta.url);
 export class HealthConstruct extends Construct {
     healthFn;
     readyFn;

package/dist/grouped-lambda-factory.d.ts

@@ -14,6 +14,8 @@ export interface HandlerEntry {
 export interface GroupedLambdaProps {
     /** Domain ID this Lambda belongs to. */
     domainId: string;
+    /** Absolute path to the domain root directory. Required for dedicated mode. */
+    domainRoot?: string;
     /** The primitive type being handled (api, subscriber, etc.). */
     primitiveType: PrimitiveType;
     /** All handler entries for this primitive type within the domain. */
@@ -36,8 +38,8 @@ export interface GroupedLambdaProps {
 /**
  * Creates either a single grouped Lambda (default) or per-handler dedicated Lambdas.
  *
- * Grouped Lambdas use an internal dispatch router: TIB_HANDLER_MAP lists all handler IDs,
- * and the incoming event/request carries a handler ID to route to the correct function.
- * When dedicated=true (escape hatch for hot/critical handlers), each handler gets its own Lambda.
+ * Dedicated mode uses NodejsFunction (esbuild on-the-fly) with auto-generated
+ * adapter wrappers — no pre-compiled dist/domains/ assets needed.
+ * Grouped mode retains Code.fromAsset for backward compatibility.
  */
 export declare function createGroupedLambdas(scope: Construct, props: GroupedLambdaProps): lambda.Function[];

package/dist/grouped-lambda-factory.js

@@ -1,26 +1,85 @@
 import * as lambda from 'aws-cdk-lib/aws-lambda';
+import * as lambdaNode from 'aws-cdk-lib/aws-lambda-nodejs';
 import * as logs from 'aws-cdk-lib/aws-logs';
 import * as cdk from 'aws-cdk-lib';
+import { writeFileSync, mkdirSync } from 'fs';
+import { join } from 'path';
+import { tmpdir } from 'os';
+function camelCase(str) {
+    return str.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
+}
+function toPascalCase(str) {
+    return str.charAt(0).toUpperCase() + camelCase(str).slice(1);
+}
+function generateDedicatedEntry(domainRoot, entry, primitiveType) {
+    const exportName = camelCase(entry.id);
+    if (primitiveType === 'schedule') {
+        return [
+            `import { hydrateCtx } from '@mettlecast/domain-runtime';`,
+            `import { ${exportName} } from '${domainRoot}/${entry.handlerFile}';`,
+            ``,
+            `export const handler = async (event: any) => {`,
+            `  const ctx = await hydrateCtx(event, {`,
+            `    databaseUrl: process.env.DATABASE_URL,`,
+            `    eventBusName: process.env.EVENT_BUS_NAME,`,
+            `  });`,
+            `  try { await ${exportName}.handler(ctx); } finally { try { await ctx.db.release(); } catch {} }`,
+            `};`,
+        ].join('\n');
+    }
+    const adapterMap = {
+        api: 'createApiLambdaHandler',
+        subscriber: 'createSubscriberLambdaHandler',
+        job: 'createJobLambdaHandler',
+        webhook: 'createWebhookLambdaHandler',
+        action: 'createActionLambdaHandler',
+    };
+    const adapter = adapterMap[primitiveType] ?? 'createApiLambdaHandler';
+    return [
+        `import { ${adapter} } from '@mettlecast/domain-runtime';`,
+        `import { ${exportName} } from '${domainRoot}/${entry.handlerFile}';`,
+        '',
+        `export const handler = ${adapter}(${exportName});`,
+    ].join('\n');
+}
+function writeTempEntry(content) {
+    const dir = join(tmpdir(), 'tib-domain-entries', `${Date.now()}-${Math.random().toString(36).slice(2)}`);
+    mkdirSync(dir, { recursive: true });
+    const filePath = join(dir, 'entry.ts');
+    writeFileSync(filePath, content, 'utf8');
+    return filePath;
+}
+const adapterCache = new Map();
 /**
  * Creates either a single grouped Lambda (default) or per-handler dedicated Lambdas.
  *
- * Grouped Lambdas use an internal dispatch router: TIB_HANDLER_MAP lists all handler IDs,
- * and the incoming event/request carries a handler ID to route to the correct function.
- * When dedicated=true (escape hatch for hot/critical handlers), each handler gets its own Lambda.
+ * Dedicated mode uses NodejsFunction (esbuild on-the-fly) with auto-generated
+ * adapter wrappers — no pre-compiled dist/domains/ assets needed.
+ * Grouped mode retains Code.fromAsset for backward compatibility.
  */
 export function createGroupedLambdas(scope, props) {
     const vpcConfig = props.vpc ? { vpc: props.vpc, securityGroups: props.securityGroups } : {};
     const logRetention = toLogRetention(props.logRetentionDays ?? 30);
     const powertoolsLayerArn = `arn:aws:lambda:${cdk.Stack.of(scope).region}:094274105915:layer:AWSLambdaPowertoolsTypeScriptV2:26`;
     if (props.dedicated) {
-        return props.handlerEntries.map(entry => {
+        if (!props.domainRoot)
+            throw new Error('domainRoot is required when dedicated=true');
+        const domainRoot = props.domainRoot;
+        const fns = props.handlerEntries.map(entry => {
             const powertoolsLayer = lambda.LayerVersion.fromLayerVersionArn(scope, `PowertoolsLayer${props.domainId}-${props.primitiveType}-${entry.id}`, powertoolsLayerArn);
-            return new lambda.Function(scope, `${props.domainId}-${props.primitiveType}-${entry.id}`, {
+            const entryContent = generateDedicatedEntry(domainRoot, entry, props.primitiveType);
+            const entryPath = writeTempEntry(entryContent);
+            return new lambdaNode.NodejsFunction(scope, `${props.domainId}-${props.primitiveType}-${entry.id}`, {
                 runtime: lambda.Runtime.NODEJS_22_X,
                 architecture: lambda.Architecture.ARM_64,
-                handler: 'index.handler',
-                code: lambda.Code.fromAsset(`dist/domains/${props.domainId}/${props.primitiveType}/${entry.id}`),
+                entry: entryPath,
+                handler: 'handler',
                 layers: [powertoolsLayer],
+                bundling: {
+                    minify: true,
+                    sourceMap: true,
+                    externalModules: ['@aws-sdk/*'],
+                },
                 environment: {
                     ...props.environment,
                     POWERTOOLS_SERVICE_NAME: `${props.domainId}-${props.primitiveType}`,
@@ -35,6 +94,7 @@ export function createGroupedLambdas(scope, props) {
                 ...vpcConfig,
             });
         });
+        return fns;
     }
     // Single grouped Lambda — all handlers for this primitive type bundled together
     const powertoolsLayer = lambda.LayerVersion.fromLayerVersionArn(scope, `PowertoolsLayer${props.domainId}-${props.primitiveType}`, powertoolsLayerArn);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mettlecast/domain-cdk-packer",
-  "version": "0.2.1",
+  "version": "0.2.4",
   "type": "module",
   "publishConfig": {
     "registry": "https://registry.npmjs.org",