hapta 1.0.11 → 1.0.13

package/index.ts

@@ -10,7 +10,7 @@ import jwt from "jsonwebtoken";
 import crypto from "crypto";
 import * as z from "zod";
 import { watch } from "fs";
-import fs from "fs" 
+import fs from "fs"
 import { pathToFileURL } from "url";
 import { MemoryState } from "./src/core/MemoryState";
 
@@ -37,9 +37,9 @@ if (!config.Database?.url || !config.Database?.Admin_Password || !config.Databas
 
 // --- Pocketbase Connection ---
 export const pb = new Pocketbase(config.Database?.url || "");
+pb.autoCancellation(false)
 try {
-    await pb.collection("_superusers").authWithPassword(config.Database?.Admin_Email || "", config.Database?.Admin_Password || "");
-    pb.autoCancellation(false)
+    await pb.collection("_superusers").authWithPassword(config.Database?.Admin_Email || "", config.Database?.Admin_Password || ""); 
 } catch (_) { }
 
 const cache = new Cache();
@@ -88,7 +88,7 @@ function isOriginAllowed(origin: string | null, corsConfig: CorsConfig): boolean
 // Build CORS headers
 function buildCorsHeaders(origin: string | null, corsConfig: CorsConfig): Record<string, string> {
     const headers: Record<string, string> = {};
-    
+
     if (origin && isOriginAllowed(origin, corsConfig)) {
         headers["Access-Control-Allow-Origin"] = origin;
     } else if (corsConfig.origins === "*") {
@@ -97,20 +97,20 @@ function buildCorsHeaders(origin: string | null, corsConfig: CorsConfig): Record
         // Use first origin as fallback
         headers["Access-Control-Allow-Origin"] = corsConfig.origins[0];
     }
-    
+
     if (corsConfig.credentials) {
         headers["Access-Control-Allow-Credentials"] = "true";
     }
-    
+
     headers["Access-Control-Allow-Methods"] = corsConfig.methods.join(", ");
     headers["Access-Control-Allow-Headers"] = corsConfig.allowedHeaders.join(", ");
-    
+
     if (corsConfig.exposedHeaders.length > 0) {
         headers["Access-Control-Expose-Headers"] = corsConfig.exposedHeaders.join(", ");
     }
-    
+
     headers["Access-Control-Max-Age"] = corsConfig.maxAge.toString();
-    
+
     return headers;
 }
 
@@ -125,7 +125,7 @@ async function createServeConfig(): Promise<Serve> {
     const schemas = new Map();
     const middlewares = new Map<string, (ctx: Context) => Promise<Response | boolean>>();
 
-    const reimportModule = async (modulePath: string) => { 
+    const reimportModule = async (modulePath: string) => {
         const resolvedPath = path.resolve(modulePath);
         if (require.cache[resolvedPath]) {
             delete require.cache[resolvedPath];
@@ -138,7 +138,7 @@ async function createServeConfig(): Promise<Serve> {
     for (const [pathname, routePath] of Object.entries(router.routes)) {
         try {
             const routeModule = await reimportModule(routePath as string);
-            
+
             // Store the entire module object for method-based routing
             routeHandlers.set(pathname, routeModule.default || routeModule);
 
@@ -155,7 +155,7 @@ async function createServeConfig(): Promise<Serve> {
                 const middleware = await reimportModule(middlewarePath);
                 if (middleware.default) middlewares.set(pathname, middleware.default);
             }
-        } catch (e) { 
+        } catch (e) {
             console.error(`❌ Error loading module for route ${pathname}:`, e);
         }
     }
@@ -178,13 +178,13 @@ async function createServeConfig(): Promise<Serve> {
                 });
             }
 
-             
+
             const routeMatch = router.match(url.pathname)
 
             if (!routeMatch) {
-                return new Response("404 Not Found", { 
+                return new Response("404 Not Found", {
                     status: 404,
-                    headers: corsHeaders 
+                    headers: corsHeaders
                 });
             }
 
@@ -193,15 +193,15 @@ async function createServeConfig(): Promise<Serve> {
             const schema = schemas.get(routeMatch.name);
 
             if (!routeHandler) {
-                return new Response(`Route handler for ${routeMatch.name} not found.`, { 
+                return new Response(`Route handler for ${routeMatch.name} not found.`, {
                     status: 404,
-                    headers: corsHeaders 
+                    headers: corsHeaders
                 });
             }
 
             try {
                 const context = await buildRequestContext(req, req.headers);
-                context.metadata.params = routeMatch.params; 
+                context.metadata.params = routeMatch.params;
                 context.metadata.query = Object.fromEntries(url.searchParams.entries());
                 context.metadata.headers = Object.fromEntries(req.headers.entries());
 
@@ -220,9 +220,9 @@ async function createServeConfig(): Promise<Serve> {
                             headers: responseHeaders,
                         });
                     }
-                    if (result === false) return new Response("Forbidden", { 
+                    if (result === false) return new Response("Forbidden", {
                         status: 403,
-                        headers: corsHeaders 
+                        headers: corsHeaders
                     });
                 }
 
@@ -233,7 +233,7 @@ async function createServeConfig(): Promise<Serve> {
                         query: schema.query?.safeParse(context.metadata.query),
                         headers: schema.headers?.safeParse(context.metadata.headers),
                     };
-                    
+
                     for (const key of ["body", "query", "headers"] as const) {
                         if (validation[key] && !validation[key]?.success) {
                             routeHandler.onError && routeHandler.onError(req, {
@@ -242,16 +242,16 @@ async function createServeConfig(): Promise<Serve> {
                                 details: validation[key]?.error.flatten(),
                             });
                             return new Response(
-                                JSON.stringify({ 
-                                    success: false, 
-                                    error: validation[key]?.error.flatten() 
-                                }), 
-                                { 
-                                    status: 400, 
+                                JSON.stringify({
+                                    success: false,
+                                    data: {error: validation[key]?.error.flatten()}
+                                }),
+                                {
+                                    status: 400,
                                     headers: {
                                         "Content-Type": "application/json",
                                         ...corsHeaders
-                                    } 
+                                    }
                                 }
                             );
                         }
@@ -261,11 +261,11 @@ async function createServeConfig(): Promise<Serve> {
                 // Get method-specific handler 
                 const methodHandler = routeHandler[method] || routeHandler.default;
                 console.log(`➡️ ${method} ${url.pathname} -> ${routeMatch.name}`);
-                
+
                 if (!methodHandler) {
                     return new Response(
-                        `Method ${method} not allowed for ${routeMatch.name}`, 
-                        { 
+                        `Method ${method} not allowed for ${routeMatch.name}`,
+                        {
                             status: 405,
                             headers: {
                                 "Allow": Object.keys(routeHandler)
@@ -279,7 +279,7 @@ async function createServeConfig(): Promise<Serve> {
 
                 // Execute the route handler
                 const response = await methodHandler(context, db);
-                
+
                 // Add CORS headers to the response
                 if (response instanceof Response) {
                     const responseHeaders = new Headers(response.headers);
@@ -292,11 +292,11 @@ async function createServeConfig(): Promise<Serve> {
                         headers: responseHeaders,
                     });
                 }
-                
+
                 return response;
             } catch (err) {
                 console.error(`❌ Error handling ${url.pathname}:`, err);
-                
+
                 // Check if route handler has custom error handler
                 if (routeHandler.onError) {
                     try {
@@ -317,10 +317,10 @@ async function createServeConfig(): Promise<Serve> {
                         console.error(`❌ Error handler also failed:`, errorHandlerErr);
                     }
                 }
-                
-                return new Response("Internal Server Error", { 
+
+                return new Response("Internal Server Error", {
                     status: 500,
-                    headers: corsHeaders 
+                    headers: corsHeaders
                 });
             }
         },
@@ -328,9 +328,9 @@ async function createServeConfig(): Promise<Serve> {
             const url = new URL(error.request.url);
             const origin = error.request.headers.get("origin");
             const corsHeaders = buildCorsHeaders(origin, defaultCorsConfig);
-            
+
             const routeMatch = router.match(url.href);
-            
+
             if (routeMatch) {
                 const routeHandler = routeHandlers.get(routeMatch.name);
                 if (routeHandler && typeof routeHandler.onError === "function") {
@@ -352,10 +352,10 @@ async function createServeConfig(): Promise<Serve> {
                     }
                 }
             }
-            
-            return new Response("Something went wrong!", { 
+
+            return new Response("Something went wrong!", {
                 status: 500,
-                headers: corsHeaders 
+                headers: corsHeaders
             });
         },
     };
@@ -402,49 +402,69 @@ function validateToken(token: string) {
     }
 }
 async function Register(data: { username: string; email: string; password: string }) {
-  try {
-    //@ts-ignore
-    data.passwordConfirm = password
-    const response = await pb.collection("users").create(data);
+    try {
+        data.passwordConfirm = data.password
+        const response = await pb.collection("users").create(data);
+        return { success: true, data: response, status: 200 };
+    } catch (err: any) {
+        const fieldErrors: Record<string, { code: string; message: string }> = {};
+
+        if (err?.data) { 
+            for (const key in err.data) {
+                let value = err.data[key];
+
+                // If value is a stringified JSON, parse it
+                if (typeof value === "string" && value.startsWith("{")) {
+                    try {
+                        value = JSON.parse(value);
+                    } catch (_) {
+                        // fallback: leave as string
+                    }
+                }
 
-    // If successful, return structured success response
-    return {
-      success: true,
-      data: response,
-      status: 200,
-    };
-  } catch (error: any) {
-    // Initialize structured error object
-    const fieldErrors: Record<string, { code: string; message: string }> = {};
-
-    // PocketBase returns error.data for field errors
-    if (error?.data) {
-      for (const key in error.data) {
-        const fieldMsg = error.data[key];
-        fieldErrors[key] = {
-          code: "validation_not_unique", // or map from PocketBase error if available
-          message: Array.isArray(fieldMsg) ? fieldMsg.join(" ") : String(fieldMsg),
+                // If value is now an object of field errors
+                if (typeof value === "object" && !Array.isArray(value)) {
+                    for (const field in value) {
+                        const msg = value[field];
+                        fieldErrors[field] = {
+                            code: msg.code || "validation_error",
+                            message: msg.message || String(msg),
+                        };
+                    }
+                } else if (Array.isArray(value)) {
+                    fieldErrors[key] = {
+                        code: "validation_error",
+                        message: value.join(" "),
+                    };
+                } else {
+                    fieldErrors[key] = {
+                        code: "validation_error",
+                        message: String(value),
+                    };
+                }
+            }
+        }
+
+        return {
+            success: false,
+            data: {
+                error: {
+                    fieldErrors,
+                    formErrors: [err?.message || "Failed to create record."],
+                },
+            },
+            status: err?.status || 400,
         };
-      }
     }
-
-    return {
-      success: false,
-      error: {
-        fieldErrors,
-        formErrors: [error?.message || "Failed to create record."],
-      },
-      status: error?.status || 400,
-    };
-  }
 }
 
+
 async function buildRequestContext(req: Request, headers: Headers): Promise<Context> {
     const reqJSON = await req.json().catch(() => ({}));
 
     const authHeader = headers.get("Authorization");
     const token = authHeader?.startsWith("Bearer ") ? authHeader.split(" ")[1] : null;
-    
+
     let isAuthenticated = false;
     let principal: any = { isAuthenticated };
 
@@ -462,22 +482,22 @@ async function buildRequestContext(req: Request, headers: Headers): Promise<Cont
         principal: { ...principal, isAuthenticated },
         services: {
             async Authenticate(options) {
-                const  { type } = options;
+                const { type } = options;
                 if (type === "passwordAuth") {
-                    const { emailOrUsername, password } = options  
-                    const login  = await pb.collection("users").authWithPassword(emailOrUsername, password) as unknown as Promise<{ record: any }>; 
+                    const { emailOrUsername, password } = options
+                    const login = await pb.collection("users").authWithPassword(emailOrUsername, password) as unknown as Promise<{ record: any }>;
                     // make a token 
-                    const token = jwt.sign({ id: (await login).record.id, username: (await login).record.username } , config.Server.JWT_Secret, { expiresIn: '1h' });
-                    
+                    const token = jwt.sign({ id: (await login).record.id, username: (await login).record.username }, config.Server.JWT_Secret, { expiresIn: '1h' });
+
                     if (login) {
                         return { isAuthenticated: true, token, ...(await login).record };
                     } else {
                         return { isAuthenticated: false };
                     }
                 }
-             },
-             Register,
-              
+            },
+            Register,
+
         },
         metadata: {
             requestID: crypto.randomUUID(),

package/package.json

@@ -3,7 +3,7 @@
   "bin": {
     "hapta": "./index.ts"
   },
-  "version": "1.0.11",
+  "version": "1.0.13",
   "description": "modular, scalable, and feature-rich backend framework designed to extend Pocketbase with authentication, schema validation, caching, and tenant-based service orchestration.",
   "dependencies": {
     "jsonwebtoken": "^9.0.3",