irgen 0.2.2 → 0.3.0

package/dist/dsl/validator.js

@@ -0,0 +1,71 @@
+export function validateSemantics(bundle) {
+    const messages = [];
+    const entities = new Set();
+    const components = new Set();
+    // DEBUG
+    // console.log("Validating bundle:", JSON.stringify(bundle, null, 2));
+    // 1. Collect Definitions (Deduplicated for reference checking)
+    for (const app of bundle.apps) {
+        const a = app;
+        // Entities
+        if (a.entities) {
+            for (const entity of a.entities) {
+                if (entities.has(entity.name)) {
+                    messages.push({ type: "error", message: `Duplicate Entity name: "${entity.name}"` });
+                }
+                entities.add(entity.name);
+            }
+        }
+        // Shared Components
+        if (a.components) {
+            for (const comp of a.components) {
+                components.add(comp.name);
+            }
+        }
+    }
+    // 2. Perform stricter checks for true duplicates (e.g. Page paths)
+    for (const app of bundle.apps) {
+        const a = app;
+        if (a.pages) {
+            const pathsInApp = new Set();
+            for (const page of a.pages) {
+                if (pathsInApp.has(page.path)) {
+                    messages.push({ type: "warning", message: `Duplicate Page path in app "${a.name}": "${page.path}"` });
+                }
+                pathsInApp.add(page.path);
+            }
+        }
+    }
+    // 3. Validate References
+    for (const app of bundle.apps) {
+        const a = app;
+        // Check Shared Components references
+        if (a.components) {
+            for (const comp of a.components) {
+                // Check entityRef
+                if (comp.entityRef && !entities.has(comp.entityRef)) {
+                    messages.push({
+                        type: "error",
+                        message: `Component "${comp.name}" references unknown Entity "${comp.entityRef}"`
+                    });
+                }
+            }
+        }
+        // Check Pages
+        if (a.pages) {
+            for (const page of a.pages) {
+                if (page.components) {
+                    for (const compCall of page.components) {
+                        if (!components.has(compCall.name)) {
+                            messages.push({
+                                type: "error",
+                                message: `Page "${page.name}" references unknown Component "${compCall.name}"`
+                            });
+                        }
+                    }
+                }
+            }
+        }
+    }
+    return messages;
+}

package/dist/emit/backend/adapters.d.ts

@@ -8,3 +8,4 @@ export declare function emitPaginationAdapter(project: Project, outDir: string,
 export declare function emitValidationAdapter(project: Project, outDir: string, policies?: any): void;
 export declare function emitResponseAdapter(project: Project, outDir: string, policies?: any): void;
 export declare function emitAuthAdapter(project: Project, outDir: string, policies?: any): void;
+export declare function emitHealthAdapter(project: Project, outDir: string, policies?: any): void;

package/dist/emit/backend/adapters.js

@@ -33,43 +33,34 @@ export function emitIdAdapter(project, outDir, policies) {
     }
 }
 export function emitLoggerAdapter(project, outDir, policies) {
-    const impl = policies?.loggerImpl ?? policies?.core?.loggerImpl ?? "console";
+    const logging = policies?.logging ?? { enabled: true, level: "info", format: "json", redact: [] };
+    const impl = policies?.loggerImpl ?? policies?.core?.loggerImpl; // Fallback for legacy
     const sf = project.createSourceFile(path.join(outDir, "lib", "logger.ts"), "", { overwrite: true });
-    sf.addStatements([`// Generated: logger adapter (${impl})`]);
-    if (impl === "console") {
+    sf.addStatements([`// Generated: logger adapter`]);
+    if (logging.enabled === false) {
         sf.addStatements([
             `export const logger = {`,
-            `  info: (...args: any[]) => console.info(...args),`,
-            `  warn: (...args: any[]) => console.warn(...args),`,
-            `  error: (...args: any[]) => console.error(...args),`,
-            `  debug: (...args: any[]) => console.debug(...args),`,
+            `  info: (..._args: any[]) => {},`,
+            `  warn: (..._args: any[]) => {},`,
+            `  error: (..._args: any[]) => {},`,
+            `  debug: (..._args: any[]) => {},`,
+            `  child: (_bindings: any) => logger,`,
             `};`,
-            ``,
-        ]);
-    }
-    else if (impl === "pino" || impl === "winston") {
-        sf.addStatements([
-            `// ${impl} adapter: please add ${impl} as a dependency in the generated project`,
-            `export const logger = {`,
-            `  info: (...args: any[]) => console.info("[logger:${impl}]", ...args),`,
-            `  warn: (...args: any[]) => console.warn("[logger:${impl}]", ...args),`,
-            `  error: (...args: any[]) => console.error("[logger:${impl}]", ...args),`,
-            `  debug: (...args: any[]) => console.debug("[logger:${impl}]", ...args),`,
-            `};`,
-            ``,
-        ]);
-    }
-    else {
-        sf.addStatements([
-            `export const logger = {`,
-            `  info: (..._args: any[]) => { throw new Error("logger implementation not provided"); },`,
-            `  warn: (..._args: any[]) => { throw new Error("logger implementation not provided"); },`,
-            `  error: (..._args: any[]) => { throw new Error("logger implementation not provided"); },`,
-            `  debug: (..._args: any[]) => { throw new Error("logger implementation not provided"); },`,
-            `};`,
-            ``,
         ]);
+        return;
     }
+    // Preference: New logging policy > legacy core.loggerImpl
+    // If user explicitly asked for 'console' in legacy, we respect it IF new policy isn't set (but new policy has defaults...)
+    // Actually, let's just make 'pino' the standard for now if enabled.
+    sf.addStatements([
+        `import pino from "pino";`,
+        ``,
+        `export const logger = pino({`,
+        `  level: ${JSON.stringify(logging.level || "info")},`,
+        ...(logging.format === "pretty" ? [`  transport: { target: "pino-pretty" },`] : []),
+        ...(logging.redact && logging.redact.length > 0 ? [`  redact: ${JSON.stringify(logging.redact)},`] : []),
+        `});`,
+    ]);
 }
 export function emitContextAdapter(project, outDir, policies) {
     const sf = project.createSourceFile(path.join(outDir, "lib", "context.ts"), "", { overwrite: true });
@@ -371,3 +362,44 @@ export function emitAuthAdapter(project, outDir, policies) {
         `export function isAuthEnabled() { return JWT_ENABLED; }`,
     ]);
 }
+export function emitHealthAdapter(project, outDir, policies) {
+    const health = policies?.health ?? { enabled: true, endpoint: "/health", metrics: { enabled: false, endpoint: "/metrics" } };
+    if (!health.enabled)
+        return;
+    const sf = project.createSourceFile(path.join(outDir, "lib", "health.ts"), "", { overwrite: true });
+    sf.addStatements([
+        `// Generated: health check and metrics adapter`,
+        `import type { Request, Response } from "express";`,
+        `import { logger } from "./logger";`,
+        ``,
+        `export async function healthCheck(req: Request, res: Response) {`,
+        `  // TODO: Add database connection check if DB is enabled`,
+        `  const status = {`,
+        `    status: "ok",`,
+        `    uptime: process.uptime(),`,
+        `    timestamp: new Date().toISOString(),`,
+        `  };`,
+        `  res.json(status);`,
+        `}`,
+        ``,
+    ]);
+    if (health.metrics?.enabled) {
+        sf.addStatements([
+            `import client from "prom-client";`,
+            ``,
+            `// Initialize metrics`,
+            `const collectDefaultMetrics = client.collectDefaultMetrics;`,
+            `collectDefaultMetrics();`,
+            ``,
+            `export async function metricsCheck(req: Request, res: Response) {`,
+            `  try {`,
+            `    res.set("Content-Type", client.register.contentType);`,
+            `    res.end(await client.register.metrics());`,
+            `  } catch (err) {`,
+            `    logger.error("Metrics error", err);`,
+            `    res.status(500).end(err);`,
+            `  }`,
+            `}`,
+        ]);
+    }
+}