kastrick 1.0.0

package/src/core/scanner.ts

@@ -0,0 +1,72 @@
+import * as fs from "fs";
+import * as path from "path";
+
+export interface FileInfo {
+  filePath: string;
+  relativePath: string;
+  name: string;
+  isDirectory: boolean;
+}
+
+export interface ApiFile {
+  path: string;
+  relativePath: string;
+  content?: string;
+}
+
+/**
+ * Scanner - scans the /api folder and extracts file structure
+ */
+export class Scanner {
+  private apiDir: string;
+
+  constructor(rootDir: string = process.cwd()) {
+    this.apiDir = path.join(rootDir, "api");
+  }
+
+  /**
+   * Check if api folder exists
+   */
+  apiDirExists(): boolean {
+    return fs.existsSync(this.apiDir);
+  }
+
+  /**
+   * Recursively scan /api folder
+   */
+  scanApiFolder(): ApiFile[] {
+    if (!this.apiDirExists()) {
+      console.warn(`⚠️  No /api folder found at ${this.apiDir}`);
+      return [];
+    }
+
+    const files: ApiFile[] = [];
+    this.scanDirectory(this.apiDir, "", files);
+    return files;
+  }
+
+  private scanDirectory(dir: string, relativePrefix: string, files: ApiFile[]): void {
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+
+    for (const entry of entries) {
+      if (entry.name.startsWith(".")) continue;
+
+      const fullPath = path.join(dir, entry.name);
+      const relativePath = path.join(relativePrefix, entry.name);
+
+      if (entry.isDirectory()) {
+        this.scanDirectory(fullPath, relativePath, files);
+      } else if (this.isApiFile(entry.name)) {
+        files.push({
+          path: fullPath,
+          relativePath: relativePath,
+          content: fs.readFileSync(fullPath, "utf-8"),
+        });
+      }
+    }
+  }
+
+  private isApiFile(filename: string): boolean {
+    return /\.(js|ts)$/.test(filename) && !filename.endsWith(".d.ts");
+  }
+}

package/src/index.ts

@@ -0,0 +1,38 @@
+// Kastrick API Logic Package
+// Main entry point
+
+export interface ApiResponse<T> {
+  success: boolean;
+  data?: T;
+  error?: string;
+}
+
+export class ApiHandler {
+  constructor(private baseUrl: string) {}
+
+  async request<T>(endpoint: string, options?: RequestInit): Promise<ApiResponse<T>> {
+    try {
+      const response = await fetch(`${this.baseUrl}${endpoint}`, options);
+      const data: any = await response.json();
+
+      if (!response.ok) {
+        return {
+          success: false,
+          error: (data?.error || 'Request failed') as string,
+        };
+      }
+
+      return {
+        success: true,
+        data: data as T,
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : 'Unknown error',
+      };
+    }
+  }
+}
+
+export default ApiHandler;

package/src/server/expressServer.ts

@@ -0,0 +1,107 @@
+import express from "express";
+import * as path from "path";
+import { ApiRoute, Router } from "../core/router";
+import { ApiFile } from "../core/scanner";
+
+/**
+ * Express Server - Dev server for local API testing
+ */
+export class ExpressServer {
+  private app: express.Application;
+  private port: number;
+  private router: Router;
+  private loadedModules: Map<string, any> = new Map();
+
+  constructor(port: number = 3000) {
+    this.app = express();
+    this.port = port;
+    this.router = new Router();
+    this.setupMiddleware();
+  }
+
+  private setupMiddleware(): void {
+    this.app.use(express.json());
+    this.app.use(express.urlencoded({ extended: true }));
+
+    // Simple logging middleware
+    this.app.use((req, res, next) => {
+      console.log(`📡 ${req.method} ${req.path}`);
+      next();
+    });
+  }
+
+  /**
+   * Register routes from API files
+   */
+  registerRoutes(files: ApiFile[]): void {
+    const routes = this.router.generateRoutes(files);
+
+    for (const route of routes) {
+      const method = route.method.toLowerCase() as keyof express.Application;
+      const filePath = route.file;
+      const content = files.find((f) => f.relativePath === filePath)?.content || "";
+
+      this.app[method](route.path, this.createHandler(filePath, route.method, content));
+    }
+
+    console.log(`📡 Registered ${routes.length} routes`);
+  }
+
+  private createHandler(filePath: string, method: string, content: string) {
+    return async (req: express.Request, res: express.Response) => {
+      try {
+        // Parse and execute handler
+        const fn = this.parseHandler(content, method);
+        if (!fn) {
+          return res.status(404).json({ error: `${method} handler not found` });
+        }
+
+        const result = await fn(req, { params: req.params });
+        res.status(result.status || 200).json(result.body !== undefined ? result.body : result);
+      } catch (err: any) {
+        console.error(`❌ Handler error in ${filePath}:`, err.message);
+        res.status(500).json({ error: err.message || "Internal server error" });
+      }
+    };
+  }
+
+  private parseHandler(content: string, method: string): any {
+    try {
+      // Extract the function from the file content
+      const moduleExports: any = {};
+
+      // Create a minimal module context
+      const module = { exports: moduleExports };
+      const exportFn = (key: string, fn: any) => {
+        moduleExports[key] = fn;
+      };
+
+      // Execute the file content in a controlled context
+      const code = `(function(exports, require, module, __filename, __dirname) { ${content} return module.exports; })`;
+      const fn = eval(code);
+      const result = fn(moduleExports, require, module, "", "");
+
+      return result[method];
+    } catch (err) {
+      console.error("Error parsing handler:", err);
+      return null;
+    }
+  }
+
+  /**
+   * Start the dev server
+   */
+  start(): void {
+    this.app.listen(this.port, () => {
+      console.log(`\n🚀 Kastrick dev server running on http://localhost:${this.port}\n`);
+      console.log(`👀 Watching for changes in /api folder...\n`);
+    });
+  }
+
+  /**
+   * Get Express app instance
+   */
+  getApp(): express.Application {
+    return this.app;
+  }
+}

package/templates/tsconfig.json

@@ -0,0 +1,20 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "commonjs",
+    "lib": ["ES2020"],
+    "types": ["node"],
+    "outDir": "./output",
+    "rootDir": "./api",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "declaration": true,
+    "sourceMap": false,
+    "noEmit": false
+  },
+  "include": ["api"],
+  "exclude": ["node_modules", "output"]
+}

package/tsconfig.json

@@ -0,0 +1,20 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "commonjs",
+    "lib": ["ES2020"],
+    "types": ["node"],
+    "outDir": "./lib",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true
+  },
+  "include": ["src"],
+  "exclude": ["node_modules"]
+}