@macedon-technologies/batman 1.12.6 → 1.14.0

package/lib/Api/ApiFiles.d.ts

@@ -0,0 +1,5 @@
+import { Construct } from 'constructs';
+import { Project } from 'projen';
+export declare class ApiFiles extends Construct {
+    constructor(project: Project);
+}

package/lib/Api/ApiFiles.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiFiles = void 0;
+const constructs_1 = require("constructs");
+const ApiFunctionFile_1 = require("./ApiFunctionFile");
+const ApiHelperFiles_1 = require("./ApiHelperFiles");
+class ApiFiles extends constructs_1.Construct {
+    constructor(project) {
+        super(project, 'ApiFiles');
+        new ApiFunctionFile_1.ApiFunctionFile(project);
+        new ApiHelperFiles_1.ApiHelperFiles(project);
+    }
+}
+exports.ApiFiles = ApiFiles;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiQXBpRmlsZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvQXBpL0FwaUZpbGVzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQUFBLDJDQUF1QztBQUV2Qyx1REFBb0Q7QUFDcEQscURBQWtEO0FBRWxELE1BQWEsUUFBUyxTQUFRLHNCQUFTO0lBRXJDLFlBQVksT0FBZ0I7UUFDMUIsS0FBSyxDQUFDLE9BQU8sRUFBRSxVQUFVLENBQUMsQ0FBQztRQUMzQixJQUFJLGlDQUFlLENBQUMsT0FBTyxDQUFDLENBQUM7UUFDN0IsSUFBSSwrQkFBYyxDQUFDLE9BQU8sQ0FBQyxDQUFDO0lBQzlCLENBQUM7Q0FDRjtBQVBELDRCQU9DIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQ29uc3RydWN0IH0gZnJvbSAnY29uc3RydWN0cyc7XG5pbXBvcnQgeyBQcm9qZWN0IH0gZnJvbSAncHJvamVuJztcbmltcG9ydCB7IEFwaUZ1bmN0aW9uRmlsZSB9IGZyb20gJy4vQXBpRnVuY3Rpb25GaWxlJztcbmltcG9ydCB7IEFwaUhlbHBlckZpbGVzIH0gZnJvbSAnLi9BcGlIZWxwZXJGaWxlcyc7XG5cbmV4cG9ydCBjbGFzcyBBcGlGaWxlcyBleHRlbmRzIENvbnN0cnVjdCB7XG5cbiAgY29uc3RydWN0b3IocHJvamVjdDogUHJvamVjdCkge1xuICAgIHN1cGVyKHByb2plY3QsICdBcGlGaWxlcycpO1xuICAgIG5ldyBBcGlGdW5jdGlvbkZpbGUocHJvamVjdCk7XG4gICAgbmV3IEFwaUhlbHBlckZpbGVzKHByb2plY3QpO1xuICB9XG59XG4iXX0=

package/lib/Api/ApiFunctionFile.d.ts

@@ -0,0 +1,4 @@
+import { Project, SampleFile } from 'projen';
+export declare class ApiFunctionFile extends SampleFile {
+    constructor(project: Project);
+}

package/lib/Api/ApiFunctionFile.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiFunctionFile = void 0;
+const projen_1 = require("projen");
+class ApiFunctionFile extends projen_1.SampleFile {
+    constructor(project) {
+        super(project, 'src/constructs/handler/Api.Function.ts', {
+            contents: `import serverless from 'serverless-http';
+import { initializeApp } from './app';
+
+export const handler = serverless(initializeApp());
+
+`,
+        });
+    }
+}
+exports.ApiFunctionFile = ApiFunctionFile;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiQXBpRnVuY3Rpb25GaWxlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL0FwaS9BcGlGdW5jdGlvbkZpbGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBQUEsbUNBQTZDO0FBRzdDLE1BQWEsZUFBZ0IsU0FBUSxtQkFBVTtJQUM3QyxZQUFZLE9BQWdCO1FBQzFCLEtBQUssQ0FBQyxPQUFPLEVBQUUsd0NBQXdDLEVBQUU7WUFDdkQsUUFBUSxFQUFFOzs7OztDQUtmO1NBQ0ksQ0FBQyxDQUFDO0lBQ0wsQ0FBQztDQUNGO0FBWEQsMENBV0MiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBQcm9qZWN0LCBTYW1wbGVGaWxlIH0gZnJvbSAncHJvamVuJztcblxuXG5leHBvcnQgY2xhc3MgQXBpRnVuY3Rpb25GaWxlIGV4dGVuZHMgU2FtcGxlRmlsZSB7XG4gIGNvbnN0cnVjdG9yKHByb2plY3Q6IFByb2plY3QpIHtcbiAgICBzdXBlcihwcm9qZWN0LCAnc3JjL2NvbnN0cnVjdHMvaGFuZGxlci9BcGkuRnVuY3Rpb24udHMnLCB7XG4gICAgICBjb250ZW50czogYGltcG9ydCBzZXJ2ZXJsZXNzIGZyb20gJ3NlcnZlcmxlc3MtaHR0cCc7XG5pbXBvcnQgeyBpbml0aWFsaXplQXBwIH0gZnJvbSAnLi9hcHAnO1xuXG5leHBvcnQgY29uc3QgaGFuZGxlciA9IHNlcnZlcmxlc3MoaW5pdGlhbGl6ZUFwcCgpKTtcblxuYCxcbiAgICB9KTtcbiAgfVxufVxuIl19

package/lib/Api/ApiHelperFiles.d.ts

@@ -0,0 +1,5 @@
+import { Construct } from 'constructs';
+import { Project } from 'projen';
+export declare class ApiHelperFiles extends Construct {
+    constructor(project: Project);
+}

package/lib/Api/ApiHelperFiles.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiHelperFiles = void 0;
+const constructs_1 = require("constructs");
+const AppHelperFile_1 = require("./AppHelperFile");
+const AppMiddlewareFiles_1 = require("./AppMiddlewareFiles");
+class ApiHelperFiles extends constructs_1.Construct {
+    constructor(project) {
+        super(project, 'ApiHelperFiles');
+        new AppHelperFile_1.AppHelperFile(project);
+        new AppMiddlewareFiles_1.AppMiddlewareFiles(project);
+    }
+}
+exports.ApiHelperFiles = ApiHelperFiles;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiQXBpSGVscGVyRmlsZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvQXBpL0FwaUhlbHBlckZpbGVzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQUFBLDJDQUF1QztBQUV2QyxtREFBZ0Q7QUFDaEQsNkRBQTBEO0FBRTFELE1BQWEsY0FBZSxTQUFRLHNCQUFTO0lBQzNDLFlBQVksT0FBZ0I7UUFDMUIsS0FBSyxDQUFDLE9BQU8sRUFBRSxnQkFBZ0IsQ0FBQyxDQUFDO1FBQ2pDLElBQUksNkJBQWEsQ0FBQyxPQUFPLENBQUMsQ0FBQztRQUMzQixJQUFJLHVDQUFrQixDQUFDLE9BQU8sQ0FBQyxDQUFDO0lBQ2xDLENBQUM7Q0FDRjtBQU5ELHdDQU1DIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQ29uc3RydWN0IH0gZnJvbSAnY29uc3RydWN0cyc7XG5pbXBvcnQgeyBQcm9qZWN0IH0gZnJvbSAncHJvamVuJztcbmltcG9ydCB7IEFwcEhlbHBlckZpbGUgfSBmcm9tICcuL0FwcEhlbHBlckZpbGUnO1xuaW1wb3J0IHsgQXBwTWlkZGxld2FyZUZpbGVzIH0gZnJvbSAnLi9BcHBNaWRkbGV3YXJlRmlsZXMnO1xuXG5leHBvcnQgY2xhc3MgQXBpSGVscGVyRmlsZXMgZXh0ZW5kcyBDb25zdHJ1Y3Qge1xuICBjb25zdHJ1Y3Rvcihwcm9qZWN0OiBQcm9qZWN0KSB7XG4gICAgc3VwZXIocHJvamVjdCwgJ0FwaUhlbHBlckZpbGVzJyk7XG4gICAgbmV3IEFwcEhlbHBlckZpbGUocHJvamVjdCk7XG4gICAgbmV3IEFwcE1pZGRsZXdhcmVGaWxlcyhwcm9qZWN0KTtcbiAgfVxufVxuIl19

package/lib/Api/AppHelperFile.d.ts

@@ -0,0 +1,4 @@
+import { Project, SampleFile } from 'projen';
+export declare class AppHelperFile extends SampleFile {
+    constructor(project: Project);
+}

package/lib/Api/AppHelperFile.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AppHelperFile = void 0;
+const projen_1 = require("projen");
+class AppHelperFile extends projen_1.SampleFile {
+    constructor(project) {
+        super(project, 'src/constructs/handler/app.ts', {
+            contents: `import express, { Express, Request, Response, Router } from 'express';
+import { ExpressApiRouter } from './ExpressApiRouter';
+import { authMiddleware } from './auth';
+import { corsMiddleware } from './cors';
+import { errorHandlerMiddleware } from './error';
+
+export const app = express();
+
+// Body parsing middleware
+app.use(express.json());
+
+// Placeholder for pre-route middleware (used by dev.ts for mock context)
+export const preRouteMiddleware: Array<express.RequestHandler> = [];
+
+export function initializeApp(): Express {
+  // Register middleware in correct order:
+  // 1. Body parsing (already done above)
+  // 2. CORS middleware (handles preflight and sets headers)
+  app.use(corsMiddleware);
+
+  // 3. Pre-route middleware (e.g., auth/mock context from dev.ts)
+  preRouteMiddleware.forEach(mw => app.use(mw));
+
+  // 4. Auth middleware (extracts userId, org role, permissions from JWT "o" claim)
+  app.use(authMiddleware);
+
+  // 5. Routes (handlers wrapped with responseFormatter)
+  const apiRouter: Router = express.Router();
+
+  // Initialize ExpressApiRouter if database client is provided
+  // if (!databaseClient) {
+  //     throw new Error('DB_ENDPOINT environment variable and database client is not set');
+  // }
+
+  const expressApiRouter = new ExpressApiRouter(
+    apiRouter,
+  );
+  app.use('/api', expressApiRouter.getRouter());
+
+  // 6. Error handler middleware (catches all errors)
+  app.use(errorHandlerMiddleware);
+
+  // Catch-all route for 404s - use regex pattern for Express 5
+  app.all(/.*/, (req: Request, res: Response) => {
+    console.debug(\`[404] \${req.method} \${req.path} - Route not found\`);
+    res.status(404).json({ error: 'Not Found', path: req.path });
+  });
+
+  return app;
+}
+`,
+        });
+    }
+}
+exports.AppHelperFile = AppHelperFile;
+//# sourceMappingURL=data:application/json;base64,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

package/lib/Api/AppMiddlewareFiles.d.ts

@@ -0,0 +1,5 @@
+import { Construct } from 'constructs';
+import { Project } from 'projen';
+export declare class AppMiddlewareFiles extends Construct {
+    constructor(project: Project);
+}

package/lib/Api/AppMiddlewareFiles.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AppMiddlewareFiles = void 0;
+const constructs_1 = require("constructs");
+const AuthMiddlewareFile_1 = require("./AuthMiddlewareFile");
+const CorsMiddlewareFile_1 = require("./CorsMiddlewareFile");
+const ErrorHandlerMiddlewareFile_1 = require("./ErrorHandlerMiddlewareFile");
+const ExpressApiRouterFile_1 = require("./ExpressApiRouterFile");
+class AppMiddlewareFiles extends constructs_1.Construct {
+    constructor(project) {
+        super(project, 'AppMiddlewareFiles');
+        new ExpressApiRouterFile_1.ExpressApiRouterFile(project);
+        new AuthMiddlewareFile_1.AuthMiddlewareFile(project);
+        new CorsMiddlewareFile_1.CorsMiddlewareFile(project);
+        new ErrorHandlerMiddlewareFile_1.ErrorHandlerMiddlewareFile(project);
+    }
+}
+exports.AppMiddlewareFiles = AppMiddlewareFiles;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiQXBwTWlkZGxld2FyZUZpbGVzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL0FwaS9BcHBNaWRkbGV3YXJlRmlsZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBQUEsMkNBQXVDO0FBRXZDLDZEQUEwRDtBQUMxRCw2REFBMEQ7QUFDMUQsNkVBQTBFO0FBQzFFLGlFQUE4RDtBQUU5RCxNQUFhLGtCQUFtQixTQUFRLHNCQUFTO0lBQy9DLFlBQVksT0FBZ0I7UUFDMUIsS0FBSyxDQUFDLE9BQU8sRUFBRSxvQkFBb0IsQ0FBQyxDQUFDO1FBQ3JDLElBQUksMkNBQW9CLENBQUMsT0FBTyxDQUFDLENBQUM7UUFDbEMsSUFBSSx1Q0FBa0IsQ0FBQyxPQUFPLENBQUMsQ0FBQztRQUNoQyxJQUFJLHVDQUFrQixDQUFDLE9BQU8sQ0FBQyxDQUFDO1FBQ2hDLElBQUksdURBQTBCLENBQUMsT0FBTyxDQUFDLENBQUM7SUFFMUMsQ0FBQztDQUVGO0FBVkQsZ0RBVUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBDb25zdHJ1Y3QgfSBmcm9tICdjb25zdHJ1Y3RzJztcbmltcG9ydCB7IFByb2plY3QgfSBmcm9tICdwcm9qZW4nO1xuaW1wb3J0IHsgQXV0aE1pZGRsZXdhcmVGaWxlIH0gZnJvbSAnLi9BdXRoTWlkZGxld2FyZUZpbGUnO1xuaW1wb3J0IHsgQ29yc01pZGRsZXdhcmVGaWxlIH0gZnJvbSAnLi9Db3JzTWlkZGxld2FyZUZpbGUnO1xuaW1wb3J0IHsgRXJyb3JIYW5kbGVyTWlkZGxld2FyZUZpbGUgfSBmcm9tICcuL0Vycm9ySGFuZGxlck1pZGRsZXdhcmVGaWxlJztcbmltcG9ydCB7IEV4cHJlc3NBcGlSb3V0ZXJGaWxlIH0gZnJvbSAnLi9FeHByZXNzQXBpUm91dGVyRmlsZSc7XG5cbmV4cG9ydCBjbGFzcyBBcHBNaWRkbGV3YXJlRmlsZXMgZXh0ZW5kcyBDb25zdHJ1Y3Qge1xuICBjb25zdHJ1Y3Rvcihwcm9qZWN0OiBQcm9qZWN0KSB7XG4gICAgc3VwZXIocHJvamVjdCwgJ0FwcE1pZGRsZXdhcmVGaWxlcycpO1xuICAgIG5ldyBFeHByZXNzQXBpUm91dGVyRmlsZShwcm9qZWN0KTtcbiAgICBuZXcgQXV0aE1pZGRsZXdhcmVGaWxlKHByb2plY3QpO1xuICAgIG5ldyBDb3JzTWlkZGxld2FyZUZpbGUocHJvamVjdCk7XG4gICAgbmV3IEVycm9ySGFuZGxlck1pZGRsZXdhcmVGaWxlKHByb2plY3QpO1xuXG4gIH1cblxufVxuIl19

package/lib/Api/AuthMiddlewareFile.d.ts

@@ -0,0 +1,4 @@
+import { Project, SampleFile } from 'projen';
+export declare class AuthMiddlewareFile extends SampleFile {
+    constructor(project: Project);
+}

package/lib/Api/AuthMiddlewareFile.js

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuthMiddlewareFile = void 0;
+const projen_1 = require("projen");
+class AuthMiddlewareFile extends projen_1.SampleFile {
+    constructor(project) {
+        super(project, 'src/constructs/handler/auth.ts', {
+            contents: `import type { Request, Response, NextFunction } from 'express';
+import jwt from 'jsonwebtoken';
+
+/**
+ * Clerk Organization role keys (without org: prefix in JWT "o.rol" claim)
+ */
+export type OrgRole = 'admin' | 'member' | 'sales_team' | 'store_managers';
+
+/**
+ * Session data extracted from Clerk JWT or authorizer context.
+ * The "o" (Organization) claim is included automatically when user has an active org.
+ */
+export interface AuthSession {
+  userId: string;
+  orgId?: string;
+  orgSlug?: string;
+  orgRole?: OrgRole;
+  permissions?: string[];
+}
+
+declare global {
+  namespace Express {
+    interface Request {
+      auth?: AuthSession;
+    }
+  }
+}
+
+/** JWT payload shape for Clerk session token with Organization claim */
+interface ClerkJwtPayload {
+  sub?: string;
+  o?: {
+    id?: string;
+    slg?: string;
+    rol?: string;
+    per?: string[];
+    fpm?: unknown;
+  };
+}
+
+/**
+ * Extracts auth session from JWT (Clerk "o" claim) or authorizer context.
+ * - Lambda/API Gateway: decodes JWT from Authorization header (already validated by Clerk authorizer)
+ * - Local dev: uses req.apiGateway.event.requestContext.authorizer
+ */
+export function authMiddleware(req: Request, _res: Response, next: NextFunction): void {
+  try {
+    // 1. Authorizer context (Lambda or local mock) - provides userId when JWT not available
+    const authorizer = (req as Request & {
+      apiGateway?: { event?: { requestContext?: { authorizer?: Record<string, unknown> } } };
+    }).apiGateway?.event?.requestContext?.authorizer;
+
+    let userId: string | undefined;
+    let orgId: string | undefined;
+    let orgSlug: string | undefined;
+    let orgRole: OrgRole | undefined;
+    let permissions: string[] | undefined;
+
+    if (authorizer && typeof authorizer.userId === 'string') {
+      userId = authorizer.userId;
+      // Authorizer may pass org data if configured
+      if (typeof authorizer.orgId === 'string') orgId = authorizer.orgId;
+      if (typeof authorizer.orgRole === 'string') orgRole = authorizer.orgRole as OrgRole;
+    }
+
+    // 2. Decode JWT for full claims (Organization "o" claim)
+    const authHeader = req.headers.authorization;
+    const token = authHeader?.startsWith('Bearer ') ? authHeader.slice(7) : undefined;
+
+    if (token) {
+      const decoded = jwt.decode(token) as ClerkJwtPayload | null;
+      if (decoded) {
+        if (!userId && decoded.sub) userId = decoded.sub;
+        if (decoded.o) {
+          if (decoded.o.id) orgId = decoded.o.id;
+          if (decoded.o.slg) orgSlug = decoded.o.slg;
+          if (decoded.o.rol) orgRole = decoded.o.rol as OrgRole;
+          if (Array.isArray(decoded.o.per)) permissions = decoded.o.per;
+        }
+      }
+    }
+
+    if (userId) {
+      req.auth = {
+        userId,
+        ...(orgId && { orgId }),
+        ...(orgSlug && { orgSlug }),
+        ...(orgRole && { orgRole }),
+        ...(permissions && permissions.length > 0 && { permissions }),
+      };
+    }
+  } catch (err) {
+    console.warn('[Auth] Failed to extract session:', err);
+  }
+  next();
+}
+`,
+        });
+    }
+}
+exports.AuthMiddlewareFile = AuthMiddlewareFile;
+//# sourceMappingURL=data:application/json;base64,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

package/lib/Api/CorsMiddlewareFile.d.ts

@@ -0,0 +1,4 @@
+import { Project, SampleFile } from 'projen';
+export declare class CorsMiddlewareFile extends SampleFile {
+    constructor(project: Project);
+}

package/lib/Api/CorsMiddlewareFile.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CorsMiddlewareFile = void 0;
+const projen_1 = require("projen");
+class CorsMiddlewareFile extends projen_1.SampleFile {
+    constructor(project) {
+        super(project, 'src/constructs/handler/cors.ts', {
+            contents: `import type { Request, Response, NextFunction } from 'express';
+
+/**
+ * Production origin for CORS
+ */
+// TODO: Change to the production origin
+const PRODUCTION_ORIGIN = process.env.ORIGIN || 'https://sample.macedon.sandbox.defiance.ai';
+
+/**
+ * Centralized CORS middleware
+ * Handles preflight OPTIONS requests and sets CORS headers
+ */
+export function corsMiddleware(req: Request, res: Response, next: NextFunction): void {
+  const origin = req.headers.origin;
+
+  // Determine allowed origin
+  let allowedOrigin: string | undefined;
+  if (origin && origin.startsWith('http://localhost:')) {
+    // Local development - allow localhost origins
+    allowedOrigin = origin;
+  } else if (origin === PRODUCTION_ORIGIN) {
+    // Production - allow configured production origin
+    allowedOrigin = PRODUCTION_ORIGIN;
+  }
+
+  // Set CORS headers
+  if (allowedOrigin) {
+    res.header('Access-Control-Allow-Origin', allowedOrigin);
+  }
+  res.header('Access-Control-Allow-Methods', 'GET, POST, PUT, DELETE, OPTIONS');
+  res.header('Access-Control-Allow-Headers', 'Origin, X-Requested-With, Content-Type, Accept, Authorization');
+  res.header('Access-Control-Allow-Credentials', 'true');
+
+  // Handle preflight OPTIONS requests
+  if (req.method === 'OPTIONS') {
+    res.sendStatus(200);
+    return;
+  }
+
+  next();
+}
+`,
+        });
+    }
+}
+exports.CorsMiddlewareFile = CorsMiddlewareFile;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiQ29yc01pZGRsZXdhcmVGaWxlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL0FwaS9Db3JzTWlkZGxld2FyZUZpbGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBQUEsbUNBQTZDO0FBRTdDLE1BQWEsa0JBQW1CLFNBQVEsbUJBQVU7SUFDaEQsWUFBWSxPQUFnQjtRQUMxQixLQUFLLENBQUMsT0FBTyxFQUFFLGdDQUFnQyxFQUFFO1lBQy9DLFFBQVEsRUFBRTs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Q0F5Q2Y7U0FDSSxDQUFDLENBQUM7SUFFTCxDQUFDO0NBRUY7QUFqREQsZ0RBaURDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgUHJvamVjdCwgU2FtcGxlRmlsZSB9IGZyb20gJ3Byb2plbic7XG5cbmV4cG9ydCBjbGFzcyBDb3JzTWlkZGxld2FyZUZpbGUgZXh0ZW5kcyBTYW1wbGVGaWxlIHtcbiAgY29uc3RydWN0b3IocHJvamVjdDogUHJvamVjdCkge1xuICAgIHN1cGVyKHByb2plY3QsICdzcmMvY29uc3RydWN0cy9oYW5kbGVyL2NvcnMudHMnLCB7XG4gICAgICBjb250ZW50czogYGltcG9ydCB0eXBlIHsgUmVxdWVzdCwgUmVzcG9uc2UsIE5leHRGdW5jdGlvbiB9IGZyb20gJ2V4cHJlc3MnO1xuXG4vKipcbiAqIFByb2R1Y3Rpb24gb3JpZ2luIGZvciBDT1JTXG4gKi9cbi8vIFRPRE86IENoYW5nZSB0byB0aGUgcHJvZHVjdGlvbiBvcmlnaW5cbmNvbnN0IFBST0RVQ1RJT05fT1JJR0lOID0gcHJvY2Vzcy5lbnYuT1JJR0lOIHx8ICdodHRwczovL3NhbXBsZS5tYWNlZG9uLnNhbmRib3guZGVmaWFuY2UuYWknO1xuXG4vKipcbiAqIENlbnRyYWxpemVkIENPUlMgbWlkZGxld2FyZVxuICogSGFuZGxlcyBwcmVmbGlnaHQgT1BUSU9OUyByZXF1ZXN0cyBhbmQgc2V0cyBDT1JTIGhlYWRlcnNcbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIGNvcnNNaWRkbGV3YXJlKHJlcTogUmVxdWVzdCwgcmVzOiBSZXNwb25zZSwgbmV4dDogTmV4dEZ1bmN0aW9uKTogdm9pZCB7XG4gIGNvbnN0IG9yaWdpbiA9IHJlcS5oZWFkZXJzLm9yaWdpbjtcblxuICAvLyBEZXRlcm1pbmUgYWxsb3dlZCBvcmlnaW5cbiAgbGV0IGFsbG93ZWRPcmlnaW46IHN0cmluZyB8IHVuZGVmaW5lZDtcbiAgaWYgKG9yaWdpbiAmJiBvcmlnaW4uc3RhcnRzV2l0aCgnaHR0cDovL2xvY2FsaG9zdDonKSkge1xuICAgIC8vIExvY2FsIGRldmVsb3BtZW50IC0gYWxsb3cgbG9jYWxob3N0IG9yaWdpbnNcbiAgICBhbGxvd2VkT3JpZ2luID0gb3JpZ2luO1xuICB9IGVsc2UgaWYgKG9yaWdpbiA9PT0gUFJPRFVDVElPTl9PUklHSU4pIHtcbiAgICAvLyBQcm9kdWN0aW9uIC0gYWxsb3cgY29uZmlndXJlZCBwcm9kdWN0aW9uIG9yaWdpblxuICAgIGFsbG93ZWRPcmlnaW4gPSBQUk9EVUNUSU9OX09SSUdJTjtcbiAgfVxuXG4gIC8vIFNldCBDT1JTIGhlYWRlcnNcbiAgaWYgKGFsbG93ZWRPcmlnaW4pIHtcbiAgICByZXMuaGVhZGVyKCdBY2Nlc3MtQ29udHJvbC1BbGxvdy1PcmlnaW4nLCBhbGxvd2VkT3JpZ2luKTtcbiAgfVxuICByZXMuaGVhZGVyKCdBY2Nlc3MtQ29udHJvbC1BbGxvdy1NZXRob2RzJywgJ0dFVCwgUE9TVCwgUFVULCBERUxFVEUsIE9QVElPTlMnKTtcbiAgcmVzLmhlYWRlcignQWNjZXNzLUNvbnRyb2wtQWxsb3ctSGVhZGVycycsICdPcmlnaW4sIFgtUmVxdWVzdGVkLVdpdGgsIENvbnRlbnQtVHlwZSwgQWNjZXB0LCBBdXRob3JpemF0aW9uJyk7XG4gIHJlcy5oZWFkZXIoJ0FjY2Vzcy1Db250cm9sLUFsbG93LUNyZWRlbnRpYWxzJywgJ3RydWUnKTtcblxuICAvLyBIYW5kbGUgcHJlZmxpZ2h0IE9QVElPTlMgcmVxdWVzdHNcbiAgaWYgKHJlcS5tZXRob2QgPT09ICdPUFRJT05TJykge1xuICAgIHJlcy5zZW5kU3RhdHVzKDIwMCk7XG4gICAgcmV0dXJuO1xuICB9XG5cbiAgbmV4dCgpO1xufVxuYCxcbiAgICB9KTtcblxuICB9XG5cbn1cbiJdfQ==

package/lib/Api/ErrorHandlerMiddlewareFile.d.ts

@@ -0,0 +1,4 @@
+import { Project, SampleFile } from 'projen';
+export declare class ErrorHandlerMiddlewareFile extends SampleFile {
+    constructor(project: Project);
+}

package/lib/Api/ErrorHandlerMiddlewareFile.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ErrorHandlerMiddlewareFile = void 0;
+const projen_1 = require("projen");
+class ErrorHandlerMiddlewareFile extends projen_1.SampleFile {
+    constructor(project) {
+        super(project, 'src/constructs/handler/error.ts', {
+            contents: `import type { Request, Response, NextFunction } from 'express';
+/**
+ * HTTP error for 4xx/5xx responses.
+ * Error middleware reads statusCode to send appropriate response.
+ */
+export class HttpError extends Error {
+  public readonly statusCode: number;
+
+  constructor(message: string, statusCode: number) {
+    super(message);
+    this.name = 'HttpError';
+    this.statusCode = statusCode;
+    Object.setPrototypeOf(this, HttpError.prototype);
+  }
+}
+
+/**
+ * Error handler middleware. Handles HttpError with statusCode; otherwise returns 500.
+ */
+export function errorHandlerMiddleware(
+  err: unknown,
+  _req: Request,
+  res: Response,
+  _next: NextFunction,
+): void {
+  if (err instanceof HttpError) {
+    res.status(err.statusCode).json({
+      error: err.statusCode >= 500 ? 'Internal Server Error' : 'Request Error',
+      message: err.message,
+    });
+    return;
+  }
+  const message = err instanceof Error ? err.message : 'Unknown error';
+  console.error('[Error]', err);
+  res.status(500).json({ error: 'Internal Server Error', message });
+}
+`,
+        });
+    }
+}
+exports.ErrorHandlerMiddlewareFile = ErrorHandlerMiddlewareFile;
+//# sourceMappingURL=data:application/json;base64,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

package/lib/Api/ExpressApiRouterFile.d.ts

@@ -0,0 +1,4 @@
+import { Project, SampleFile } from 'projen';
+export declare class ExpressApiRouterFile extends SampleFile {
+    constructor(project: Project);
+}

package/lib/Api/ExpressApiRouterFile.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExpressApiRouterFile = void 0;
+const projen_1 = require("projen");
+class ExpressApiRouterFile extends projen_1.SampleFile {
+    constructor(project) {
+        super(project, 'src/constructs/handler/ExpressApiRouter.ts', {
+            contents: `import { Request, Response, Router } from 'express';
+
+export class ExpressApiRouter {
+  private readonly router: Router;
+
+  constructor(router: Router) {
+    this.router = router;
+    this.setupRoutes();
+  }
+
+
+  /**
+   * Gets the Express router instance
+   *
+   * @returns Router The Express router
+   */
+  public getRouter(): Router {
+    return this.router;
+  }
+
+  /**
+   * Sets up all available routes
+   */
+  private setupRoutes(): void {
+    this.router.get('/test', async (req: Request, res: Response) => {
+      console.log('Hello World');
+      return res.status(200).json({ message: 'Hello World' });
+    });
+
+    /**
+     * Session endpoint: returns current user's org roles and permissions from Clerk JWT.
+     * The "o" claim is included automatically when user has an active organization.
+     */
+    this.router.get('/session', (req: Request, res: Response) => {
+      const auth = req.auth;
+      if (!auth) {
+        return res.status(401).json({ error: 'Unauthorized', message: 'No session' });
+      }
+      return res.status(200).json({
+        userId: auth.userId,
+        orgId: auth.orgId ?? null,
+        orgSlug: auth.orgSlug ?? null,
+        orgRole: auth.orgRole ?? null,
+        permissions: auth.permissions ?? [],
+      });
+    });
+  }
+}
+`,
+        });
+    }
+}
+exports.ExpressApiRouterFile = ExpressApiRouterFile;
+//# sourceMappingURL=data:application/json;base64,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

package/lib/Application.js

@@ -1,13 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Application = void 0;
+const ApiFiles_1 = require("./Api/ApiFiles");
 const ApiConstructFile_1 = require("./ApiConstructFile");
-const ApiFunctionFile_1 = require("./ApiFunctionFile");
 const ApplicationStackFile_1 = require("./ApplicationStackFile");
 const BaseApplicationStackFile_1 = require("./BaseApplicationStackFile");
 const CodeRabbitFile_1 = require("./CodeRabbitFile");
 const GitHubRolesStackFile_1 = require("./GitHubRolesStackFile");
-const LocalDevAppFile_1 = require("./LocalDevAppFile");
+const LocalDevFiles_1 = require("./LocalDevFiles");
 const MainFile_1 = require("./MainFile");
 const MainTestFile_1 = require("./MainTestFile");
 const PrCleanupWorkflow_1 = require("./PrCleanupWorkflow");
@@ -30,7 +30,7 @@ class Application {
             prod: options.prod,
             additionalTags: options.additionalTags,
         });
-        new LocalDevAppFile_1.LocalDevAppFile(project, {
+        new LocalDevFiles_1.LocalDevFiles(project, {
             projectName: project.name,
             dev: options.dev,
         });
@@ -48,8 +48,8 @@ class Application {
             new WorkflowProvider_1.WorkflowProviderFile(project);
             new WorkflowAutoDiscover_1.WorkflowAutoDiscover(project);
         }
-        // Create handler files
-        new ApiFunctionFile_1.ApiFunctionFile(project);
+        // Create handler files and API backend logic files
+        new ApiFiles_1.ApiFiles(project);
         // Create test files
         new MainTestFile_1.MainTestFile(project);
         // Create config files
@@ -80,4 +80,4 @@ class Application {
     }
 }
 exports.Application = Application;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/BatmanProject.js

@@ -1,5 +1,4 @@
 "use strict";
-var _a;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BatmanProject = void 0;
 const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
@@ -12,6 +11,7 @@ const GitHubRolesFile_1 = require("./GitHubRolesFile");
 const utils_1 = require("./utils");
 const ViteReactProject_1 = require("./ViteReactProject");
 class BatmanProject extends awscdk_1.AwsCdkTypeScriptApp {
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@macedon-technologies/batman.BatmanProject", version: "1.14.0" };
     constructor(options) {
         super({
             ...options,
@@ -116,6 +116,4 @@ class BatmanProject extends awscdk_1.AwsCdkTypeScriptApp {
     }
 }
 exports.BatmanProject = BatmanProject;
-_a = JSII_RTTI_SYMBOL_1;
-BatmanProject[_a] = { fqn: "@macedon-technologies/batman.BatmanProject", version: "1.12.6" };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"BatmanProject.js","sourceRoot":"","sources":["../src/BatmanProject.ts"],"names":[],"mappings":"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","sourcesContent":["import { AwsCdkTypeScriptApp, AwsCdkTypeScriptAppOptions } from 'projen/lib/awscdk';\nimport { GithubCredentials } from 'projen/lib/github';\nimport { Application, ApplicationEnvironmentConfig } from './Application';\nimport { CodeOwnersFile } from './CodeOwnersFile';\nimport { DataDogAspectFile } from './DataDogAspectFile';\nimport { GitHubRolesFile } from './GitHubRolesFile';\nimport { readmeContents } from './utils';\nimport { ViteReactProject } from './ViteReactProject';\n\nexport interface BatmanProjectOptions extends AwsCdkTypeScriptAppOptions {\n\n  /**\n   * Development environment configuration\n   */\n  readonly dev: ApplicationEnvironmentConfig;\n\n  /**\n   * Development environment configuration\n   */\n  readonly staging: ApplicationEnvironmentConfig;\n\n  /**\n   * Production environment configuration\n   */\n  readonly prod: ApplicationEnvironmentConfig;\n\n  /**\n   * Additional tags to apply to all stacks\n   */\n  readonly additionalTags?: { [key: string]: string };\n\n  /**\n   * Enable n8n workflow auto-discovery and WorkflowProvider generation\n   */\n  readonly n8nWorkflows?: boolean;\n\n  /**\n   * Additional code owners to add to the CODEOWNERS file\n   */\n  readonly additionalCodeOwners?: string[];\n\n  /**\n   * Website dependencies\n   */\n  readonly websiteDeps?: string[];\n}\n\n\nexport class BatmanProject extends AwsCdkTypeScriptApp {\n  constructor(options: BatmanProjectOptions) {\n    super({\n      ...options,\n      cdkVersion: options.cdkVersion || '2.224.0',\n      defaultReleaseBranch: options.defaultReleaseBranch || 'main',\n      name: options.name,\n      projenrcTs: true,\n      buildWorkflow: false,\n      deps: [\n        '@types/aws-lambda',\n        '@types/express',\n        '@types/pg',\n        'pg',\n        '@aws-sdk/rds-signer',\n        '@matthewbonig/secret',\n        'datadog-cdk-constructs-v2',\n        '@cdklabs/aws-lambda-rust',\n        '@aws-lambda-powertools/parameters',\n        'jsonwebtoken',\n        '@aws-sdk/client-secrets-manager',\n        'express',\n        'serverless-http',\n        ...options.deps || [],\n      ],\n      devDeps: [\n        '@types/jsonwebtoken',\n        'nodemon',\n        'concurrently',\n        '@macedon-technologies/batman@^1.0.0',\n        ...options.devDeps || [],\n      ],\n      gitignore: [\n        'src/constructs/handler/clerk-authorizer/target/**',\n        '**/.DS_Store',\n        ...options.gitignore || [],\n      ],\n      tsconfig: {\n        ...options.tsconfig,\n        compilerOptions: {\n          ...options.tsconfig?.compilerOptions,\n          isolatedModules: true,\n          allowImportingTsExtensions: true,\n        },\n      },\n      sampleCode: false,\n      minNodeVersion: options.minNodeVersion || '22',\n      depsUpgradeOptions: {\n        workflowOptions: {\n          projenCredentials: GithubCredentials.fromPersonalAccessToken({\n            secret: 'GITHUB_TOKEN',\n          }),\n        },\n      },\n      readme: {\n        contents: readmeContents(options.name),\n      },\n    });\n\n\n    // Create standard project files\n    const PRIMARY_ACCOUNT = '015955817263';\n    const PRIMARY_REGION = 'us-east-1';\n\n    new Application(this, {\n      githubRepository: `macedon-technologies/${options.name}`,\n      dev: {\n        ...options.dev,\n      },\n      staging: {\n        ...options.staging,\n      },\n      prod: {\n        ...options.dev,\n      },\n      additionalTags: options.additionalTags,\n      n8nWorkflows: options.n8nWorkflows,\n    });\n\n    new GitHubRolesFile(this, {\n      account: PRIMARY_ACCOUNT,\n      primaryRegion: PRIMARY_REGION,\n    });\n\n    new CodeOwnersFile(this, {\n      additionalOwners: options.additionalCodeOwners,\n    });\n\n    new DataDogAspectFile(this);\n\n    const viteReact = new ViteReactProject({\n      name: options.name,\n      defaultReleaseBranch: 'main',\n      parent: this,\n      outdir: 'web',\n      deps: options.websiteDeps,\n    });\n    viteReact.addConfigField('something', 'number');\n    viteReact.addConfigField('somethingElse', 'string');\n\n    const concurrently = (...args: string[]) => {\n      return `concurrently ${args.map(a => `\"${a}\"`).join(' ')}`;\n    };\n\n    this.addTask('dev', {\n      exec: concurrently(\n        'nodemon --watch ./src/constructs/handler --watch ./local/dev.ts ./local/dev.ts',\n        viteReact.devCommand,\n      ),\n    });\n\n    this.addTask('cdk:dev', {\n      exec: 'yarn cdk -a \"npx ts-node -P tsconfig.json --prefer-ts-exts src/LocalDevApp.ts\"',\n      receiveArgs: true,\n    });\n\n\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"BatmanProject.js","sourceRoot":"","sources":["../src/BatmanProject.ts"],"names":[],"mappings":"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","sourcesContent":["import { AwsCdkTypeScriptApp, AwsCdkTypeScriptAppOptions } from 'projen/lib/awscdk';\nimport { GithubCredentials } from 'projen/lib/github';\nimport { Application, ApplicationEnvironmentConfig } from './Application';\nimport { CodeOwnersFile } from './CodeOwnersFile';\nimport { DataDogAspectFile } from './DataDogAspectFile';\nimport { GitHubRolesFile } from './GitHubRolesFile';\nimport { readmeContents } from './utils';\nimport { ViteReactProject } from './ViteReactProject';\n\nexport interface BatmanProjectOptions extends AwsCdkTypeScriptAppOptions {\n\n  /**\n   * Development environment configuration\n   */\n  readonly dev: ApplicationEnvironmentConfig;\n\n  /**\n   * Development environment configuration\n   */\n  readonly staging: ApplicationEnvironmentConfig;\n\n  /**\n   * Production environment configuration\n   */\n  readonly prod: ApplicationEnvironmentConfig;\n\n  /**\n   * Additional tags to apply to all stacks\n   */\n  readonly additionalTags?: { [key: string]: string };\n\n  /**\n   * Enable n8n workflow auto-discovery and WorkflowProvider generation\n   */\n  readonly n8nWorkflows?: boolean;\n\n  /**\n   * Additional code owners to add to the CODEOWNERS file\n   */\n  readonly additionalCodeOwners?: string[];\n\n  /**\n   * Website dependencies\n   */\n  readonly websiteDeps?: string[];\n}\n\n\nexport class BatmanProject extends AwsCdkTypeScriptApp {\n  constructor(options: BatmanProjectOptions) {\n    super({\n      ...options,\n      cdkVersion: options.cdkVersion || '2.224.0',\n      defaultReleaseBranch: options.defaultReleaseBranch || 'main',\n      name: options.name,\n      projenrcTs: true,\n      buildWorkflow: false,\n      deps: [\n        '@types/aws-lambda',\n        '@types/express',\n        '@types/pg',\n        'pg',\n        '@aws-sdk/rds-signer',\n        '@matthewbonig/secret',\n        'datadog-cdk-constructs-v2',\n        '@cdklabs/aws-lambda-rust',\n        '@aws-lambda-powertools/parameters',\n        'jsonwebtoken',\n        '@aws-sdk/client-secrets-manager',\n        'express',\n        'serverless-http',\n        ...options.deps || [],\n      ],\n      devDeps: [\n        '@types/jsonwebtoken',\n        'nodemon',\n        'concurrently',\n        '@macedon-technologies/batman@^1.0.0',\n        ...options.devDeps || [],\n      ],\n      gitignore: [\n        'src/constructs/handler/clerk-authorizer/target/**',\n        '**/.DS_Store',\n        ...options.gitignore || [],\n      ],\n      tsconfig: {\n        ...options.tsconfig,\n        compilerOptions: {\n          ...options.tsconfig?.compilerOptions,\n          isolatedModules: true,\n          allowImportingTsExtensions: true,\n        },\n      },\n      sampleCode: false,\n      minNodeVersion: options.minNodeVersion || '22',\n      depsUpgradeOptions: {\n        workflowOptions: {\n          projenCredentials: GithubCredentials.fromPersonalAccessToken({\n            secret: 'GITHUB_TOKEN',\n          }),\n        },\n      },\n      readme: {\n        contents: readmeContents(options.name),\n      },\n    });\n\n\n    // Create standard project files\n    const PRIMARY_ACCOUNT = '015955817263';\n    const PRIMARY_REGION = 'us-east-1';\n\n    new Application(this, {\n      githubRepository: `macedon-technologies/${options.name}`,\n      dev: {\n        ...options.dev,\n      },\n      staging: {\n        ...options.staging,\n      },\n      prod: {\n        ...options.dev,\n      },\n      additionalTags: options.additionalTags,\n      n8nWorkflows: options.n8nWorkflows,\n    });\n\n    new GitHubRolesFile(this, {\n      account: PRIMARY_ACCOUNT,\n      primaryRegion: PRIMARY_REGION,\n    });\n\n    new CodeOwnersFile(this, {\n      additionalOwners: options.additionalCodeOwners,\n    });\n\n    new DataDogAspectFile(this);\n\n    const viteReact = new ViteReactProject({\n      name: options.name,\n      defaultReleaseBranch: 'main',\n      parent: this,\n      outdir: 'web',\n      deps: options.websiteDeps,\n    });\n    viteReact.addConfigField('something', 'number');\n    viteReact.addConfigField('somethingElse', 'string');\n\n    const concurrently = (...args: string[]) => {\n      return `concurrently ${args.map(a => `\"${a}\"`).join(' ')}`;\n    };\n\n    this.addTask('dev', {\n      exec: concurrently(\n        'nodemon --watch ./src/constructs/handler --watch ./local/dev.ts ./local/dev.ts',\n        viteReact.devCommand,\n      ),\n    });\n\n    this.addTask('cdk:dev', {\n      exec: 'yarn cdk -a \"npx ts-node -P tsconfig.json --prefer-ts-exts src/LocalDevApp.ts\"',\n      receiveArgs: true,\n    });\n\n\n  }\n}\n"]}