@harpy-js/core 0.5.1 → 0.5.3

package/scripts/build.ts

@@ -0,0 +1,93 @@
+#!/usr/bin/env node
+
+import { spawn } from "child_process";
+import { Logger } from "./logger";
+
+const logger = new Logger("Builder");
+
+async function runCommand(cmd: string, args: string[] = []): Promise<void> {
+  return new Promise((resolve, reject) => {
+    const proc = spawn(cmd, args, { stdio: "inherit", shell: true });
+    proc.on("close", (code) => {
+      if (code !== 0) {
+        reject(new Error(`Command failed with code ${code}`));
+      } else {
+        resolve();
+      }
+    });
+  });
+}
+
+async function buildNestApp(): Promise<void> {
+  logger.log("Building NestJS application...");
+  try {
+    await runCommand("nest", ["build"]);
+  } catch (error) {
+    logger.error(`NestJS build failed: ${error}`);
+    throw error;
+  }
+}
+
+async function buildHydration(): Promise<void> {
+  logger.log("Building hydration components...");
+  try {
+    const tsxPath = require("child_process")
+      .execSync("which tsx", { encoding: "utf-8" })
+      .trim();
+    await runCommand(tsxPath, [
+      require("path").join(__dirname, "build-hydration.ts"),
+    ]);
+  } catch (error) {
+    logger.error(`Hydration build failed: ${error}`);
+    throw error;
+  }
+}
+
+async function autoWrap(): Promise<void> {
+  logger.log("Auto-wrapping client components...");
+  try {
+    const tsxPath = require("child_process")
+      .execSync("which tsx", { encoding: "utf-8" })
+      .trim();
+    await runCommand(tsxPath, [
+      require("path").join(__dirname, "auto-wrap-exports.ts"),
+    ]);
+  } catch (error) {
+    logger.error(`Auto-wrap failed: ${error}`);
+    throw error;
+  }
+}
+
+async function buildStyles(): Promise<void> {
+  logger.log("Building styles...");
+  try {
+    const tsxPath = require("child_process")
+      .execSync("which tsx", { encoding: "utf-8" })
+      .trim();
+    await runCommand(tsxPath, [
+      require("path").join(__dirname, "build-page-styles.ts"),
+    ]);
+  } catch (error) {
+    logger.error(`Styles build failed: ${error}`);
+    throw error;
+  }
+}
+
+async function main(): Promise<void> {
+  try {
+    logger.log("Starting production build...");
+
+    await buildNestApp();
+    await buildHydration();
+    await autoWrap();
+    await buildStyles();
+
+    logger.log("Production build complete!");
+    process.exit(0);
+  } catch (error) {
+    logger.error(`Build failed: ${error}`);
+    process.exit(1);
+  }
+}
+
+main();

package/scripts/dev.ts

@@ -3,6 +3,9 @@
 import { spawn } from "child_process";
 import * as fs from "fs";
 import * as http from "http";
+import { Logger } from "./logger";
+
+const logger = new Logger("DevServer");
 
 let nestProcess: any = null;
 let isRebuilding = false;
@@ -43,43 +46,52 @@ async function runCommand(cmd: string, args: string[] = []): Promise<void> {
 }
 
 async function buildHydration(): Promise<void> {
-  console.log("🔧 Building hydration...");
+  logger.log("Building hydration components...");
   try {
-    await runCommand("pnpm", ["build:hydration"]);
-    console.log("✅ Hydration built");
+    const tsxPath = require("child_process")
+      .execSync("which tsx", { encoding: "utf-8" })
+      .trim();
+    await runCommand(tsxPath, [
+      require("path").join(__dirname, "build-hydration.ts"),
+    ]);
   } catch (error) {
-    console.error("❌ Hydration build failed:", error);
+    logger.error(`Hydration build failed: ${error}`);
     throw error;
   }
 }
 
 async function autoWrap(): Promise<void> {
-  console.log("🔄 Auto-wrapping client components...");
+  logger.log("Auto-wrapping client components...");
   try {
-    await runCommand("pnpm", ["auto-wrap"]);
-    console.log("✅ Auto-wrap complete");
+    const tsxPath = require("child_process")
+      .execSync("which tsx", { encoding: "utf-8" })
+      .trim();
+    await runCommand(tsxPath, [
+      require("path").join(__dirname, "auto-wrap-exports.ts"),
+    ]);
   } catch (error) {
-    console.error("❌ Auto-wrap failed:", error);
-    throw error;
+    logger.error(`Auto-wrap failed: ${error}`);
   }
 }
 
 async function buildStyles(): Promise<void> {
-  console.log("🎨 Building styles...");
+  logger.log("Building styles...");
   try {
-    await runCommand("pnpm", ["build:styles"]);
-    console.log("✅ Styles built");
+    const tsxPath = require("child_process")
+      .execSync("which tsx", { encoding: "utf-8" })
+      .trim();
+    await runCommand(tsxPath, [
+      require("path").join(__dirname, "build-page-styles.ts"),
+    ]);
   } catch (error) {
-    console.error("❌ Styles build failed:", error);
-    throw error;
+    logger.error(`Styles build failed: ${error}`);
   }
 }
 
 async function startNestServer(): Promise<void> {
   return new Promise((resolve) => {
-    console.log("🚀 Starting NestJS server from compiled dist...");
+    logger.log("Starting NestJS application...");
     // Run compiled dist/main.js instead of using ts-node
-    // This ensures auto-wrapped components are used
     nestProcess = spawn("node", ["--watch", "dist/main.js"], {
       stdio: "pipe",
       shell: false,
@@ -106,15 +118,14 @@ async function startNestServer(): Promise<void> {
           setTimeout(async () => {
             if (isRebuilding) return;
             isRebuilding = true;
-            console.log("\n🔄 NestJS rebuild detected, rebuilding assets...");
+            logger.log("Rebuilding assets after code change...");
             try {
               await buildHydration();
               await autoWrap();
               await buildStyles();
-              console.log("✅ Assets rebuilt\n");
               triggerBrowserReload();
             } catch (error) {
-              console.error("❌ Asset rebuild failed:", error);
+              logger.error(`Asset rebuild failed: ${error}`);
             } finally {
               isRebuilding = false;
             }
@@ -139,10 +150,9 @@ async function startNestServer(): Promise<void> {
 }
 
 function watchSourceChanges(): void {
-  console.log("👀 Watching source files for changes...");
+  logger.log("Watching source files for changes...");
 
   let debounceTimer: NodeJS.Timeout | null = null;
-  const watchedFiles = new Set<string>();
 
   // Watch src for CSS changes only (TS/TSX changes are handled by NestJS watch + stdout detection)
   fs.watch("src", { recursive: true }, async (eventType, filename) => {
@@ -168,14 +178,13 @@ function watchSourceChanges(): void {
 
     debounceTimer = setTimeout(async () => {
       isRebuilding = true;
-      console.log(`\n📝 CSS file changed: ${filename}`);
+      logger.log(`CSS file changed: ${filename}`);
 
       try {
         await buildStyles();
-        console.log("✅ Styles rebuilt\n");
         triggerBrowserReload();
       } catch (error) {
-        console.error("Build error:", error);
+        logger.error(`Style rebuild failed: ${error}`);
       } finally {
         watchedFiles.delete(filename);
         isRebuilding = false;
@@ -188,7 +197,7 @@ let tscProcess: any = null;
 
 async function startTypeScriptWatch(): Promise<void> {
   return new Promise((resolve) => {
-    console.log("⚙️  Starting TypeScript compiler in watch mode...");
+    logger.log("Starting TypeScript compiler in watch mode...");
     tscProcess = spawn("pnpm", ["nest", "build", "--watch"], {
       stdio: "pipe",
       shell: true,
@@ -215,13 +224,13 @@ async function startTypeScriptWatch(): Promise<void> {
 
 async function main(): Promise<void> {
   try {
-    console.log("📦 Initializing development environment...\n");
+    logger.log("Initializing development environment...");
 
     // First: Start TypeScript compiler in watch mode
     await startTypeScriptWatch();
 
     // Build initial assets after first compilation
-    console.log("\n🔧 Building hydration assets...");
+    logger.log("Building initial assets...");
     await buildHydration();
     await autoWrap();
     await buildStyles();
@@ -229,27 +238,27 @@ async function main(): Promise<void> {
     // Now start the node server with compiled dist files
     await startNestServer();
 
-    console.log("\n✅ Development server ready!\n");
+    logger.log("Development server ready!");
 
     // Watch for source changes
     watchSourceChanges();
 
     // Handle graceful shutdown
     process.on("SIGINT", async () => {
-      console.log("\n\n🛑 Stopping development server...");
+      logger.log("Stopping development server...");
       if (tscProcess) tscProcess.kill();
       if (nestProcess) nestProcess.kill();
       process.exit(0);
     });
 
     process.on("SIGTERM", async () => {
-      console.log("\n\n🛑 Stopping development server...");
+      logger.log("Stopping development server...");
       if (tscProcess) tscProcess.kill();
       if (nestProcess) nestProcess.kill();
       process.exit(0);
     });
   } catch (error) {
-    console.error("Fatal error:", error);
+    logger.error(`Fatal error: ${error}`);
     process.exit(1);
   }
 }

package/scripts/logger.ts

@@ -0,0 +1,53 @@
+/**
+ * Logger utility to format logs matching NestJS style
+ * Format: [Harpy] PID  - DATE, TIME     LEVEL [Context] Message +Xms
+ */
+
+const pid = process.pid;
+
+function getTimestamp(): string {
+  const now = new Date();
+  const date = now.toLocaleDateString("en-US");
+  const time = now.toLocaleTimeString("en-US");
+  return `${date}, ${time}`;
+}
+
+export class Logger {
+  private context: string;
+  private lastLogTime: number = Date.now();
+
+  constructor(context: string) {
+    this.context = context;
+  }
+
+  private formatMessage(level: string, message: string, levelColor: string): string {
+    const timestamp = getTimestamp();
+    const elapsed = Date.now() - this.lastLogTime;
+    this.lastLogTime = Date.now();
+    
+    const harpyPid = `\x1b[32m[Harpy] ${pid}\x1b[0m`;  // green
+    const timestampFormatted = `\x1b[37m${timestamp}\x1b[0m`;  // white
+    const levelColored = `\x1b[${levelColor}m${level.padEnd(5)}\x1b[0m`;
+    const contextColored = `\x1b[33m[${this.context}]\x1b[0m`;  // yellow
+    const messageColored = `\x1b[${levelColor}m${message}\x1b[0m`;
+    const elapsedColored = `\x1b[33m+${elapsed}ms\x1b[0m`;  // yellow
+    
+    return `${harpyPid}  - ${timestampFormatted}     ${levelColored} ${contextColored} ${messageColored} ${elapsedColored}`;
+  }
+
+  log(message: string): void {
+    console.log(this.formatMessage("LOG", message, "32")); // green
+  }
+
+  error(message: string): void {
+    console.error(this.formatMessage("ERROR", message, "31")); // red
+  }
+
+  warn(message: string): void {
+    console.warn(this.formatMessage("WARN", message, "33")); // yellow
+  }
+
+  verbose(message: string): void {
+    console.log(this.formatMessage("LOG", message, "36")); // cyan
+  }
+}

package/scripts/start.ts

@@ -0,0 +1,41 @@
+#!/usr/bin/env node
+
+import { spawn } from "child_process";
+import { Logger } from "./logger";
+
+const logger = new Logger("Server");
+
+function startServer(): void {
+  logger.log("Starting production server...");
+
+  const serverProcess = spawn("node", ["dist/main.js"], {
+    stdio: "inherit",
+    shell: false,
+    cwd: process.cwd(),
+  });
+
+  serverProcess.on("error", (error) => {
+    logger.error(`Failed to start server: ${error.message}`);
+    process.exit(1);
+  });
+
+  serverProcess.on("exit", (code) => {
+    if (code !== 0) {
+      logger.error(`Server exited with code ${code}`);
+      process.exit(code || 1);
+    }
+  });
+
+  // Handle termination signals
+  process.on("SIGINT", () => {
+    logger.log("Shutting down server...");
+    serverProcess.kill("SIGINT");
+  });
+
+  process.on("SIGTERM", () => {
+    logger.log("Shutting down server...");
+    serverProcess.kill("SIGTERM");
+  });
+}
+
+startServer();

package/src/cli.ts

@@ -10,12 +10,14 @@ const scripts: Record<string, string> = {
   "build-hydration": path.join(__dirname, "../scripts/build-hydration.ts"),
   "auto-wrap": path.join(__dirname, "../scripts/auto-wrap-exports.ts"),
   "build-styles": path.join(__dirname, "../scripts/build-page-styles.ts"),
+  build: path.join(__dirname, "../scripts/build.ts"),
+  start: path.join(__dirname, "../scripts/start.ts"),
   dev: path.join(__dirname, "../scripts/dev.ts"),
 };
 
 if (!command || !scripts[command]) {
   console.error("Usage: harpy <command>");
-  console.error("Commands: build-hydration, auto-wrap, build-styles, dev");
+  console.error("Commands: build, start, dev, build-hydration, auto-wrap, build-styles");
   process.exit(1);
 }
 

package/src/index.ts

@@ -11,6 +11,10 @@ export { JsxRender } from "./decorators/jsx.decorator";
 export { WithLayout } from "./decorators/layout.decorator";
 export type { MetaOptions, RenderOptions } from "./decorators/jsx.decorator";
 
+// SEO Module
+export { SeoModule, BaseSeoService, DefaultSeoService } from "./seo";
+export type { SitemapUrl, RobotsConfig, SeoModuleOptions } from "./seo";
+
 // I18n is provided in a separate package: @harpy-js/i18n
 // Consumers should import i18n types and modules from that package.
 
@@ -29,3 +33,4 @@ export {
   getActiveItemIdFromIndex,
   getActiveItemIdFromManifest,
 } from "./client/getActiveItemId";
+export { useI18n } from "./client/use-i18n";

package/src/seo/index.ts

@@ -0,0 +1,5 @@
+export { SeoModule } from './seo.module';
+export { BaseSeoService, DefaultSeoService } from './seo.service';
+export { RobotsController } from './robots.controller';
+export { SitemapController } from './sitemap.controller';
+export type { SitemapUrl, RobotsConfig, SeoModuleOptions } from './seo.types';

package/src/seo/robots.controller.ts

@@ -0,0 +1,15 @@
+import { Controller, Get, Header } from '@nestjs/common';
+import { BaseSeoService } from './seo.service';
+
+@Controller('robots.txt')
+export class RobotsController {
+  constructor(private readonly seoService: BaseSeoService) {}
+
+  @Get()
+  @Header('Content-Type', 'text/plain')
+  @Header('Cache-Control', 'public, max-age=86400') // Cache for 24 hours
+  getRobots(): string {
+    const config = this.seoService.getRobotsConfig();
+    return this.seoService.formatRobotsTxt(config);
+  }
+}

package/src/seo/seo.module.ts

@@ -0,0 +1,59 @@
+import { Module, DynamicModule, Type } from '@nestjs/common';
+import { RobotsController } from './robots.controller';
+import { SitemapController } from './sitemap.controller';
+import {
+  BaseSeoService,
+  DefaultSeoService,
+  SEO_MODULE_OPTIONS,
+} from './seo.service';
+import type { SeoModuleOptions } from './seo.types';
+
+@Module({})
+export class SeoModule {
+  /**
+   * Register the SEO module with default implementation
+   */
+  static forRoot(options?: SeoModuleOptions): DynamicModule {
+    return {
+      module: SeoModule,
+      controllers: [RobotsController, SitemapController],
+      providers: [
+        {
+          provide: SEO_MODULE_OPTIONS,
+          useValue: options || {},
+        },
+        {
+          provide: BaseSeoService,
+          useClass: DefaultSeoService,
+        },
+      ],
+      exports: [BaseSeoService],
+    };
+  }
+
+  /**
+   * Register the SEO module with a custom service implementation
+   * @param customService Your custom service that extends BaseSeoService
+   * @param options Optional configuration options
+   */
+  static forRootWithService(
+    customService: Type<BaseSeoService>,
+    options?: SeoModuleOptions,
+  ): DynamicModule {
+    return {
+      module: SeoModule,
+      controllers: [RobotsController, SitemapController],
+      providers: [
+        {
+          provide: SEO_MODULE_OPTIONS,
+          useValue: options || {},
+        },
+        {
+          provide: BaseSeoService,
+          useClass: customService,
+        },
+      ],
+      exports: [BaseSeoService],
+    };
+  }
+}

package/src/seo/seo.service.ts

@@ -0,0 +1,161 @@
+import { Injectable, Inject, Optional } from '@nestjs/common';
+import type { SitemapUrl, RobotsConfig, SeoModuleOptions } from './seo.types';
+
+export const SEO_MODULE_OPTIONS = 'SEO_MODULE_OPTIONS';
+
+@Injectable()
+export abstract class BaseSeoService {
+  protected readonly baseUrl: string;
+
+  constructor(
+    @Optional()
+    @Inject(SEO_MODULE_OPTIONS)
+    protected readonly options?: SeoModuleOptions,
+  ) {
+    this.baseUrl = options?.baseUrl || 'http://localhost:3000';
+  }
+
+  /**
+   * Override this method to provide custom sitemap URLs
+   * This can fetch from database, CMS, or any other source
+   */
+  abstract getSitemapUrls(): Promise<SitemapUrl[]>;
+
+  /**
+   * Override this method to provide custom robots.txt configuration
+   */
+  abstract getRobotsConfig(): RobotsConfig;
+
+  /**
+   * Format sitemap URLs to XML string
+   */
+  formatSitemapXml(urls: SitemapUrl[]): string {
+    const urlEntries = urls
+      .map((entry) => {
+        const lastmod = entry.lastModified
+          ? new Date(entry.lastModified).toISOString()
+          : new Date().toISOString();
+
+        return `  <url>
+    <loc>${this.escapeXml(entry.url)}</loc>
+    <lastmod>${lastmod}</lastmod>
+    ${entry.changeFrequency ? `<changefreq>${entry.changeFrequency}</changefreq>` : ''}
+    ${entry.priority !== undefined ? `<priority>${entry.priority}</priority>` : ''}
+  </url>`;
+      })
+      .join('\n');
+
+    return `<?xml version="1.0" encoding="UTF-8"?>
+<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
+${urlEntries}
+</urlset>`;
+  }
+
+  /**
+   * Format robots.txt configuration to string
+   */
+  formatRobotsTxt(config: RobotsConfig): string {
+    const rules = Array.isArray(config.rules) ? config.rules : [config.rules];
+
+    const rulesText = rules
+      .map((rule) => {
+        const userAgents = Array.isArray(rule.userAgent)
+          ? rule.userAgent
+          : [rule.userAgent];
+        const allows = rule.allow
+          ? Array.isArray(rule.allow)
+            ? rule.allow
+            : [rule.allow]
+          : [];
+        const disallows = rule.disallow
+          ? Array.isArray(rule.disallow)
+            ? rule.disallow
+            : [rule.disallow]
+          : [];
+
+        let text = userAgents.map((ua) => `User-agent: ${ua}`).join('\n');
+
+        if (allows.length > 0) {
+          text += '\n' + allows.map((path) => `Allow: ${path}`).join('\n');
+        }
+
+        if (disallows.length > 0) {
+          text +=
+            '\n' + disallows.map((path) => `Disallow: ${path}`).join('\n');
+        }
+
+        if (rule.crawlDelay) {
+          text += `\nCrawl-delay: ${rule.crawlDelay}`;
+        }
+
+        return text;
+      })
+      .join('\n\n');
+
+    let result = rulesText;
+
+    if (config.sitemap) {
+      const sitemaps = Array.isArray(config.sitemap)
+        ? config.sitemap
+        : [config.sitemap];
+      result += '\n\n' + sitemaps.map((s) => `Sitemap: ${s}`).join('\n');
+    }
+
+    if (config.host) {
+      result += `\n\nHost: ${config.host}`;
+    }
+
+    return result;
+  }
+
+  protected escapeXml(str: string): string {
+    return str
+      .replace(/&/g, '&amp;')
+      .replace(/</g, '&lt;')
+      .replace(/>/g, '&gt;')
+      .replace(/"/g, '&quot;')
+      .replace(/'/g, '&apos;');
+  }
+}
+
+/**
+ * Default SEO service implementation
+ * Users can extend BaseSeoService to provide custom implementations
+ */
+@Injectable()
+export class DefaultSeoService extends BaseSeoService {
+  async getSitemapUrls(): Promise<SitemapUrl[]> {
+    const now = new Date();
+
+    // Default homepage only
+    return [
+      {
+        url: this.baseUrl,
+        lastModified: now,
+        changeFrequency: 'daily',
+        priority: 1.0,
+      },
+    ];
+  }
+
+  getRobotsConfig(): RobotsConfig {
+    const defaultConfig: RobotsConfig = {
+      rules: {
+        userAgent: '*',
+        allow: '/',
+      },
+      sitemap: `${this.baseUrl}/sitemap.xml`,
+      host: this.baseUrl,
+    };
+
+    // Merge with options if provided
+    if (this.options?.robotsConfig) {
+      return {
+        ...defaultConfig,
+        ...this.options.robotsConfig,
+      };
+    }
+
+    return defaultConfig;
+  }
+}

package/src/seo/seo.types.ts

@@ -0,0 +1,40 @@
+export interface SitemapUrl {
+  url: string;
+  lastModified?: Date | string;
+  changeFrequency?:
+    | 'always'
+    | 'hourly'
+    | 'daily'
+    | 'weekly'
+    | 'monthly'
+    | 'yearly'
+    | 'never';
+  priority?: number;
+  alternates?: {
+    languages?: Record<string, string>;
+  };
+}
+
+export interface RobotsConfig {
+  rules:
+    | {
+        userAgent: string | string[];
+        allow?: string | string[];
+        disallow?: string | string[];
+        crawlDelay?: number;
+      }
+    | Array<{
+        userAgent: string | string[];
+        allow?: string | string[];
+        disallow?: string | string[];
+        crawlDelay?: number;
+      }>;
+  sitemap?: string | string[];
+  host?: string;
+}
+
+export interface SeoModuleOptions {
+  baseUrl: string;
+  robotsConfig?: Partial<RobotsConfig>;
+  sitemapGenerator?: () => Promise<SitemapUrl[]>;
+}