hapta 1.0.2 → 1.0.4

package/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -1,252 +1,252 @@
-
-# 🛠️ **Hapta**
-
-**Hapta** is a modular, scalable, and feature-rich backend framework designed to extend [Pocketbase](https://pocketbase.io) with authentication, schema validation, caching, and tenant-based service orchestration.
-
-> Designed to integrate easily into any modern Node.js backend — and purpose-built to unlock Pocketbase for production-scale deployments.
-
----
-
-## 📦 Installation
-
-```bash
-npm install hapta
-# or
-bun add hapta
-# or
-yarn add hapta
-```
-
----
-
-## 🚀 Key Features
-
-* ✅ **Authentication via Clover**
-  Multi-strategy login (OAuth, password, OTP, MFA) with tenant role/clearance support.
-
-* 🔐 **Context-Based Auth (`ctx.principal`)**
-  Automatically injects authenticated user state and metadata into each request.
-
-* 📦 **Zod-Based Schema Validation**
-  Auto-validates route inputs with fully typed schema files.
-
-* ⚡ **Smart Caching Layer**
-  Dynamic TTL, auto-invalidation, optimistic scaffolds, and memory-based caching.
-
-* 🧱 **Modular Context System**
-  Unified `Context` class handles services, request metadata, auth, and responses.
-
-* 🏗️ **Batch Write Mode**
-  Queue DB changes, defer execution, and optimize complex flows.
-
----
-
-## 📁 Project Structure (Recommended)
-
-```
-/
-  └── routes/
-      └── auth/
-          └── index.ts        # Example auth endpoint
-  └── schemas/
-      └── auth/
-          └── index.ts        # Zod validation for auth route
- 
-```
-
----
-
-## 🧠 Quick Start
-
-### 🧩 Set up config
-> hapta-config.json
-```json 
-{
-    "port": 8080,
-    "logLevel": "info",
-    "origin":"http://localhost:8081",
-    "AI_ENABLED": false,
-    "Clover_Tenant_ID": "",
-    "Clover_Secret":"",
-    "Clover_Server_Url":"clover.postlyapp.com",
-    "JWT_SECRET":"*",
-    "DatabaseUrl":"http://localhost:8080",
-    "ADMIN_EMAIL":"malikwhitterb@gmail.com",
-    "ADMIN_PASSWORD":""
-}
-
-```
-
-### 🔐 Use the `principal`
-
-```ts
-if (ctx.principal.isAuthenticated) {
-  const username = ctx.principal.username;
-  const clearance = ctx.principal.highest_clearance;
-}
-```
-
----
-
-## ⚙️ Usage Example
-
-### `/routes/auth/index.ts`
-
-```ts
-import Context from "hapta";
-import { Database } from "hapta";
-
-export default async function POST(ctx: Context, DB: Database) {
-  const { type } = ctx.metadata.query as any;
-
-  if (type === "oauth") {
-    const result = await ctx.services.Clover.Authenticate({ type: "oauth", ...ctx.metadata.query });
-
-    return result.isAuthenticated
-      ? ctx.json(result)
-      : ctx.json({ error: true, message: "OAuth failed" }, 401);
-
-  } else if (type === "password") {
-    const result = await ctx.services.Clover.Authenticate({
-      type: "passwordAuth",
-      ...ctx.metadata.json
-    });
-
-    return result.isAuthenticated
-      ? ctx.json(result)
-      : ctx.json({ error: true, message: "Invalid credentials" }, 400);
-  }
-
-  return ctx.json({ error: true, message: "Unsupported auth type" }, 400);
-}
-```
-
-## Then simply run
-
-```bash
-bun --hot run hapta
-```
-
----
-
-## 🧬 Database API
-
-```ts
-import { DatabaseService } from "hapta";
-
-const DB = new DatabaseService(pocketbase, cacheHandler);
-```
-
-### 🔹 Get one (cached)
-
-```ts
-const record = await DB.get("users", "abc123");
-```
-
-### 🔹 List (cached + paginated)
-
-```ts
-await DB.list("posts", { page: 1, limit: 20 });
-```
-
-### 🔹 Create with scaffold
-
-```ts
-DB.setBatch(true);
-await DB.create("comments", { body: "Hello!" }, true);
-await DB.saveChanges();
-```
-
----
-
-## 🧰 Built-in Response Helpers
-
-```ts
-ctx.json({ success: true }, 200);
-ctx.html("<h1>Welcome</h1>");
-ctx.text("Hello world");
-```
-
-All responses include CORS headers out of the box:
-
-```http
-Access-Control-Allow-Origin: *
-Access-Control-Allow-Headers: Content-Type, Authorization
-```
-
----
-
-## 🧪 Validation with Zod
-
-```ts
-// /schemas/auth/index.ts
-import { z } from "zod";
-
-export default z.object({
-  emailOrUsername: z.string().min(3),
-  password: z.string().min(6),
-});
-```
-
-Hapta automatically loads and validates this schema for `/auth` requests before your handler runs.
-
----
-
-## 🔄 Batch Mode
-
-```ts
-DB.setBatch(true);
-await DB.create("logs", { message: "Init" });
-await DB.update("users", "abc", { active: false });
-await DB.delete("sessions", "xyz");
-await DB.saveChanges(); // executes all queued ops
-```
-
----
-
-## 📦 Caching Details
-
-| Method     | Caches | TTL     | Invalidation                    |
-| ---------- | ------ | ------- | ------------------------------- |
-| `get()`    | ✅      | dynamic | on `update`, `delete`           |
-| `list()`   | ✅      | dynamic | on `create`, `update`, `delete` |
-| `create()` | ➖      | ➖       | invalidates all list caches     |
-| `update()` | ➖      | ➖       | invalidates list + get cache    |
-| `delete()` | ➖      | ➖       | invalidates list + get cache    |
-
----
-
-## 🧱 Integrating with Express, Bun, or Custom Server
-
-You can wire Hapta into any server environment:
-
-```ts
-const ctx = new Context();
-// inject principal, services, metadata, etc.
-ctx.metadata = {
-  requestID: "xyz",
-  timestamp: new Date(),
-  json: await req.json(),
-  headers: req.headers,
-  ...
-};
-
-// call route handler
-const res = await handler(ctx, DB);
-return res;
-```
-
----
-
-## 🧾 License
-
-MIT © Postr-Inc — Built for scale.
-
----
-
-## 💬 Questions?
-
-* Open an issue
-* PRs welcome
-* Built with ❤️ by the Postr-Inc team
- 
+
+# 🛠️ **Hapta**
+
+**Hapta** is a modular, scalable, and feature-rich backend framework designed to extend [Pocketbase](https://pocketbase.io) with authentication, schema validation, caching, and tenant-based service orchestration.
+
+> Designed to integrate easily into any modern Node.js backend — and purpose-built to unlock Pocketbase for production-scale deployments.
+
+---
+
+## 📦 Installation
+
+```bash
+npm install hapta
+# or
+bun add hapta
+# or
+yarn add hapta
+```
+
+---
+
+## 🚀 Key Features
+
+* ✅ **Authentication via Clover**
+  Multi-strategy login (OAuth, password, OTP, MFA) with tenant role/clearance support.
+
+* 🔐 **Context-Based Auth (`ctx.principal`)**
+  Automatically injects authenticated user state and metadata into each request.
+
+* 📦 **Zod-Based Schema Validation**
+  Auto-validates route inputs with fully typed schema files.
+
+* ⚡ **Smart Caching Layer**
+  Dynamic TTL, auto-invalidation, optimistic scaffolds, and memory-based caching.
+
+* 🧱 **Modular Context System**
+  Unified `Context` class handles services, request metadata, auth, and responses.
+
+* 🏗️ **Batch Write Mode**
+  Queue DB changes, defer execution, and optimize complex flows.
+
+---
+
+## 📁 Project Structure (Recommended)
+
+```
+/
+  └── routes/
+      └── auth/
+          └── index.ts        # Example auth endpoint
+  └── schemas/
+      └── auth/
+          └── index.ts        # Zod validation for auth route
+ 
+```
+
+---
+
+## 🧠 Quick Start
+
+### 🧩 Set up config
+> hapta-config.json
+```json 
+{
+    "port": 8080,
+    "logLevel": "info",
+    "origin":"http://localhost:8081",
+    "AI_ENABLED": false,
+    "Clover_Tenant_ID": "",
+    "Clover_Secret":"",
+    "Clover_Server_Url":"clover.postlyapp.com",
+    "JWT_SECRET":"*",
+    "DatabaseUrl":"http://localhost:8080",
+    "ADMIN_EMAIL":"malikwhitterb@gmail.com",
+    "ADMIN_PASSWORD":""
+}
+
+```
+
+### 🔐 Use the `principal`
+
+```ts
+if (ctx.principal.isAuthenticated) {
+  const username = ctx.principal.username;
+  const clearance = ctx.principal.highest_clearance;
+}
+```
+
+---
+
+## ⚙️ Usage Example
+
+### `/routes/auth/index.ts`
+
+```ts
+import Context from "hapta";
+import { Database } from "hapta";
+
+export default async function POST(ctx: Context, DB: Database) {
+  const { type } = ctx.metadata.query as any;
+
+  if (type === "oauth") {
+    const result = await ctx.services.Clover.Authenticate({ type: "oauth", ...ctx.metadata.query });
+
+    return result.isAuthenticated
+      ? ctx.json(result)
+      : ctx.json({ error: true, message: "OAuth failed" }, 401);
+
+  } else if (type === "password") {
+    const result = await ctx.services.Clover.Authenticate({
+      type: "passwordAuth",
+      ...ctx.metadata.json
+    });
+
+    return result.isAuthenticated
+      ? ctx.json(result)
+      : ctx.json({ error: true, message: "Invalid credentials" }, 400);
+  }
+
+  return ctx.json({ error: true, message: "Unsupported auth type" }, 400);
+}
+```
+
+## Then simply run
+
+```bash
+bun --hot run hapta
+```
+
+---
+
+## 🧬 Database API
+
+```ts
+import { DatabaseService } from "hapta";
+
+const DB = new DatabaseService(pocketbase, cacheHandler);
+```
+
+### 🔹 Get one (cached)
+
+```ts
+const record = await DB.get("users", "abc123");
+```
+
+### 🔹 List (cached + paginated)
+
+```ts
+await DB.list("posts", { page: 1, limit: 20 });
+```
+
+### 🔹 Create with scaffold
+
+```ts
+DB.setBatch(true);
+await DB.create("comments", { body: "Hello!" }, true);
+await DB.saveChanges();
+```
+
+---
+
+## 🧰 Built-in Response Helpers
+
+```ts
+ctx.json({ success: true }, 200);
+ctx.html("<h1>Welcome</h1>");
+ctx.text("Hello world");
+```
+
+All responses include CORS headers out of the box:
+
+```http
+Access-Control-Allow-Origin: *
+Access-Control-Allow-Headers: Content-Type, Authorization
+```
+
+---
+
+## 🧪 Validation with Zod
+
+```ts
+// /schemas/auth/index.ts
+import { z } from "zod";
+
+export default z.object({
+  emailOrUsername: z.string().min(3),
+  password: z.string().min(6),
+});
+```
+
+Hapta automatically loads and validates this schema for `/auth` requests before your handler runs.
+
+---
+
+## 🔄 Batch Mode
+
+```ts
+DB.setBatch(true);
+await DB.create("logs", { message: "Init" });
+await DB.update("users", "abc", { active: false });
+await DB.delete("sessions", "xyz");
+await DB.saveChanges(); // executes all queued ops
+```
+
+---
+
+## 📦 Caching Details
+
+| Method     | Caches | TTL     | Invalidation                    |
+| ---------- | ------ | ------- | ------------------------------- |
+| `get()`    | ✅      | dynamic | on `update`, `delete`           |
+| `list()`   | ✅      | dynamic | on `create`, `update`, `delete` |
+| `create()` | ➖      | ➖       | invalidates all list caches     |
+| `update()` | ➖      | ➖       | invalidates list + get cache    |
+| `delete()` | ➖      | ➖       | invalidates list + get cache    |
+
+---
+
+## 🧱 Integrating with Express, Bun, or Custom Server
+
+You can wire Hapta into any server environment:
+
+```ts
+const ctx = new Context();
+// inject principal, services, metadata, etc.
+ctx.metadata = {
+  requestID: "xyz",
+  timestamp: new Date(),
+  json: await req.json(),
+  headers: req.headers,
+  ...
+};
+
+// call route handler
+const res = await handler(ctx, DB);
+return res;
+```
+
+---
+
+## 🧾 License
+
+MIT © Postr-Inc — Built for scale.
+
+---
+
+## 💬 Questions?
+
+* Open an issue
+* PRs welcome
+* Built with ❤️ by the Postr-Inc team
+ 

package/helpers/HTTP/Request/Context.ts

@@ -1,5 +1,5 @@
 import { config } from "../../../src/core/config";
-export const corsHeaders = {
+const corsHeaders = {
   "Access-Control-Allow-Origin": config.origin,
   "Access-Control-Allow-Methods": "OPTIONS, GET, POST, PUT, PATCH, DELETE",
   "Access-Control-Allow-Headers": "Content-Type, Authorization",
@@ -80,7 +80,7 @@ type TokenOptions = {
   iat: number
 } 
 type VerifyFn = (token: string) => Promise<Principal>;
-type TempTokenFn = (amount_of_uses: number, expiresAt: '1h' | '1d' | '1y'|'') => Promise<string | null>
+ 
 export type ServiceConfigs = {
   Clover: {
     Tenant_ID: string;
@@ -88,8 +88,7 @@ export type ServiceConfigs = {
     Authorized_Users: string[];
     Authenticate: AuthenticateFn; 
     Register: RegisterFn;
-    Verify?: VerifyFn; 
-    createTemporaryToken: TempTokenFn           // just verify token
+    Verify?: VerifyFn;            // just verify token
   };
 };
 
@@ -207,4 +206,4 @@ export default class Context implements IContext {
       }
     });
   }
-}
+}

package/index.ts

@@ -25,8 +25,8 @@ const router = new FileSystemRouter({
 
 // --- Validation: Ensure required config vars are present ---
 if (!config.Clover_Secret || !config.Clover_Tenant_ID) {
-    console.error("❌ Clover_Secret and Clover_Tenant_ID must be set in your config.");
-    process.exit(1);
+    console.error("Using Basic Auth");
+
 }
 
 if (!config.ADMIN_EMAIL || !config.ADMIN_PASSWORD) {
@@ -34,7 +34,7 @@ if (!config.ADMIN_EMAIL || !config.ADMIN_PASSWORD) {
     process.exit(1);
 }
 
-if(!fs.existsSync(path.join(process.cwd(), "routes"))){
+if (!fs.existsSync(path.join(process.cwd(), "routes"))) {
     console.error("❌ Please create a routes folder and create your first route");
     process.exit(1);
 }
@@ -46,16 +46,19 @@ try {
 } catch (_) { }
 
 // --- Primary Tenant Data ---
-const primaryTenantData = await fetch(`${config.Clover_Server_Url}/tenants/${config.Clover_Tenant_ID}`, {
+var primaryTenantData: any = {};
+if(config.Clover_Tenant_ID){
+primaryTenantData = await fetch(`${config.Clover_Server_Url}/tenants/${config.Clover_Tenant_ID}`, {
     headers: { Authorization_Secret: config.Clover_Secret },
 }).then(async (res) => {
     if (!res.ok) throw new Error(`Failed to fetch primary tenant data: ${res.status} ${res.statusText}`);
     return res.json();
 });
+}
 console.log("✅ Primary tenant data loaded.");
 
 const cache = new Cache();
-const db = new DatabaseService(pb, cache); 
+const db = new DatabaseService(pb, cache);
 // --- Server Configuration Builder ---
 async function createServeConfig(): Promise<Serve> {
     console.log("🛠️ Building server configuration...");
@@ -67,7 +70,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];
@@ -94,7 +97,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);
         }
     }
@@ -105,7 +108,7 @@ async function createServeConfig(): Promise<Serve> {
         port: config.port,
         async fetch(req: Request) {
             console.log(req.method)
-            if (req.method === "OPTIONS") { 
+            if (req.method === "OPTIONS") {
                 console.log("ran")
                 return new Response(null, {
                     status: 200,
@@ -130,7 +133,7 @@ async function createServeConfig(): Promise<Serve> {
             const schema = schemas.get(routeMatch.name);
 
             if (!routeHandler) {
-                return new Response(`Route handler for ${routeMatch.name} not found.`, { status: 404, headers:{...corsHeaders} });
+                return new Response(`Route handler for ${routeMatch.name} not found.`, { status: 404, headers: { ...corsHeaders } });
             }
 
             try {
@@ -147,7 +150,6 @@ async function createServeConfig(): Promise<Serve> {
                     if (result instanceof Response) return result;
                     if (result === false) return new Response("Forbidden", { status: 403 });
                 }
-
                 if (schema) {
                     const validation = {
                         body: schema.body?.safeParse(context.metadata.json),
@@ -156,7 +158,7 @@ async function createServeConfig(): Promise<Serve> {
                     };
                     for (const key of ["body", "query", "headers"] as const) {
                         if (validation[key] && !validation[key]?.success) {
-                            return new Response(JSON.stringify({ success: false, error: validation[key]?.error.flatten() }), { status: 400, headers: { "Content-Type": "application/json" , ...corsHeaders} });
+                            return new Response(JSON.stringify({ success: false, error: validation[key]?.error.flatten() }), { status: 400, headers: { "Content-Type": "application/json", ...corsHeaders } });
                         }
                     }
                 }
@@ -166,12 +168,12 @@ async function createServeConfig(): Promise<Serve> {
                 return await routeHandler(context, db);
             } catch (err) {
                 console.error(`❌ Error handling ${url.pathname}:`, err);
-                return new Response("Internal Server Error", { status: 500, headers:{...corsHeaders} });
+                return new Response("Internal Server Error", { status: 500, headers: { ...corsHeaders } });
             }
         },
         error(error) {
             console.error("☠️ Uncaught Error:", error);
-            return new Response("Something went wrong!", { status: 500, headers:{...corsHeaders} });
+            return new Response("Something went wrong!", { status: 500, headers: { ...corsHeaders } });
         },
     };
 }
@@ -220,20 +222,19 @@ async function buildRequestContext(req: Request, headers: Headers) {
     const reqJSON = await req.json().catch(() => ({}));
 
     const hasToken = headers.has("Authorization")
-    var isAuthenticated = false; 
+    var isAuthenticated = false;
     if (hasToken) {
-         
+
         try {
-            
+
             isAuthenticated = true
         } catch (error) {
             isAuthenticated = false
         }
     }
-    const context  = {
+    const context = {
         principal: { isAuthenticated: isAuthenticated as boolean },
-        services: {
-            Clover: {
+        services: { 
                 Tenant_ID: primaryTenantData.id,
                 Authorized_Users: primaryTenantData.expand?.Tenant_Groups?.Users || [],
                 Register: async (data: any) => {
@@ -257,77 +258,100 @@ async function buildRequestContext(req: Request, headers: Headers) {
                     return await res.json()
 
                 },
-                Authenticate: async (options) => {
-                    const fetchBody = {
-                        Tenant_Id: primaryTenantData.id,
-                        Secret: config.Clover_Secret,
-                        type: options.type,
-                    };
+                Authenticate: async (options: any) => {
+                    if (config.Clover_Tenant_ID) {
+                        const fetchBody = {
+                            Tenant_Id: primaryTenantData.id,
+                            Secret: config.Clover_Secret,
+                            type: options.type,
+                        };
 
-                    if (options.type === "passwordAuth") {
-                        fetchBody.emailOrUsername = options.emailOrUsername;
-                        fetchBody.password = options.password;
-                    }
+                        if (options.type === "passwordAuth") {
+                            fetchBody.emailOrUsername = options.emailOrUsername;
+                            fetchBody.password = options.password;
+                        }
 
-                    if (options.type === "oauth") {
-                        fetchBody.code = options.code;
-                        fetchBody.redirectUri = options.redirectUri;
-                        fetchBody.client_secret = config.Clover_Secret
-                        fetchBody.authenticated_id = options.authenticated_id
-                    }
+                        if (options.type === "oauth") {
+                            fetchBody.code = options.code;
+                            fetchBody.redirectUri = options.redirectUri;
+                            fetchBody.client_secret = config.Clover_Secret
+                            fetchBody.authenticated_id = options.authenticated_id
+                        }
 
 
-                    const authRes = await fetch(`${config.Clover_Server_Url}/${options.type === "oauth" ? 'oauth/token' :'auth'}`, {
-                        method: "POST",
-                        headers: {
-                            "Content-Type": "application/json",
-                            Authorization_Secret: config.Clover_Secret,
-                            tenantid: config.Clover_Tenant_ID,
-                            "User-Agent": headers.get("User-Agent") || "",
-                        },
-                        body: JSON.stringify(fetchBody),
-                    });
+                        const authRes = await fetch(`${config.Clover_Server_Url}/${options.type === "oauth" ? 'oauth/token' : 'auth'}`, {
+                            method: "POST",
+                            headers: {
+                                "Content-Type": "application/json",
+                                Authorization_Secret: config.Clover_Secret,
+                                tenantid: config.Clover_Tenant_ID,
+                                "User-Agent": headers.get("User-Agent") || "",
+                            },
+                            body: JSON.stringify(fetchBody),
+                        });
+
+                        if (!authRes.ok) {
+                            return {
+                                isAuthenticated: false,
+                                error: true,
+                                message: "Authentication failed",
+                            };
+                        }
 
-                    if (!authRes.ok) {  
-                        return {
-                            isAuthenticated: false,
-                            error: true,
-                            message: "Authentication failed",
-                        };
+                        const responseJson = await authRes.json();
+                        const record = responseJson.AuthenticatedModal;
+                        record.clover_assigned_id = primaryTenantData.id;
+                        token_uses.set(record.token, 0)
+
+                        record.token = jwt.sign(
+                            {
+                                id: record.id,
+                                clover_assigned_id: record.clover_assigned_id,
+                                Roles: record.Roles,
+                                Group: record.clover_group_assigned_To,
+                                Token_Uses: token_uses.get(token) || 0
+                            },
+                            config.JWT_SECRET,
+                        );
+
+                        record.isAuthenticated = true;
+
+                        return record;
+                    } else {
+                        switch (options.type) {
+                            case "passwordAuth":
+                                if(options.password && options.emailOrUsername){
+                                    try {
+                                    const { record } = await pb.collection("users").authWithPassword(options.emailOrUsername, options.password);
+                                   
+                                    record.token = jwt.sign( {
+                                         id: record.id,
+                                         token_uses: 0 
+                                    }, config.JWT_SECRET)
+                                    token_uses.set(record.token, 0)
+                                    return record
+                                    } catch (error) {
+                                         console.error(error);
+                                        return { isAuthenticated: false, error: true, message: "Authentication failed" };
+                                    }
+                                }
+                        }
                     }
-
-                    const responseJson = await authRes.json();
-                    const record = responseJson.AuthenticatedModal;
-                    record.clover_assigned_id = primaryTenantData.id;
-
-                    record.token = jwt.sign(
-                        {
-                            id: record.id,
-                            clover_assigned_id: record.clover_assigned_id,
-                            Roles: record.Roles,
-                            Group: record.clover_group_assigned_To,
-                        },
-                        config.JWT_SECRET,
-                    );
-
-                    record.isAuthenticated = true;
-
-                    return record;
                 },
-                Verify: async (token) => {
+                Verify: async (token: string) => {
                     try {
                         const payload = jwt.verify(token, config.JWT_SECRET);
-                        if(token_uses.has(token) && token_uses.get(token) >= payload.amount_of_uses){
+                        if (token_uses.has(token) && token_uses.get(token) >= payload.amount_of_uses) {
                             // this is basic auth token
                             throw new Error("token has been used wayy to many times, it is expired")
-                        }else{
+                        } else {
                             token_uses.set(token, Number(token_uses.get(token)) + 1)
                         }
                         return {
-                            isAuthenticated: true, 
+                            isAuthenticated: true,
                             id: payload.id || crypto.randomUUID(),
                             clover_group_assigned_To: payload.Group || [],
-                            clover_assigned_id: payload.clover_assigned_id || primaryTenantData.id,
+                            clover_assigned_id: config.Clover_Tenant_ID ? payload.clover_assigned_id  ?   config.Clover_Tenant_ID : payload.clover_assigned_id : null,
                             Roles: payload.Roles || [],
                             token,
                         };
@@ -336,14 +360,14 @@ async function buildRequestContext(req: Request, headers: Headers) {
                     }
                 },
                 createTemporaryToken(amount_of_uses: number, expiresAt: string) {
-                    const token = jwt.sign({amount_of_uses, isBasicAuth: true, security_level: 0}, config.JWT_SECRET,  { expiresIn: expiresAt })
+                    const token = jwt.sign({ amount_of_uses, isBasicAuth: true, security_level: 0 }, config.JWT_SECRET, { expiresIn: expiresAt })
                     token_uses.set(token, 0)
                     return token
                 },
                 Roles: Array.isArray(primaryTenantData.Tenant_Roles)
                     ? primaryTenantData.Tenant_Roles
                     : [primaryTenantData.Tenant_Roles],
-            },
+           
         },
         metadata: {
             requestID: crypto.randomUUID(),
@@ -351,12 +375,12 @@ async function buildRequestContext(req: Request, headers: Headers) {
             params: {},
             query: {},
             json: reqJSON,
-            headers : {}
+            headers: {}
         },
         tenantId: headers.get("tenantid") ?? undefined,
-        json: (value: any, status?: number, statusText?:string) => {
+        json: (value: any, status?: number, statusText?: string) => {
             return Response.json(value, {
-                ...(status && {status}),
+                ...(status && { status }),
                 headers: {
                     "Access-Control-Allow-Origin": config.origin,
                     "Access-Control-Allow-Methods": "GET,PATCH,PUT,DELETE",
@@ -367,9 +391,9 @@ async function buildRequestContext(req: Request, headers: Headers) {
 
         html: (value: string, status: number, statusText?: string) => {
             return new Response(value, {
-                ...(status && {status}),
-                ...(statusText && {statusText}),
-                headers:{
+                ...(status && { status }),
+                ...(statusText && { statusText }),
+                headers: {
                     "Content-Type": "text/html",
                     "Access-Control-Allow-Origin": config.origin,
                     "Access-Control-Allow-Methods": "GET,PATCH,PUT,DELETE",
@@ -377,11 +401,11 @@ async function buildRequestContext(req: Request, headers: Headers) {
                 }
             })
         },
-        text: (value: string, status?:number, statusText?: string) => {
+        text: (value: string, status?: number, statusText?: string) => {
             return new Response(value, {
-                 ...(status && {status}),
-                ...(statusText && {statusText}),
-                headers:{
+                ...(status && { status }),
+                ...(statusText && { statusText }),
+                headers: {
                     "Content-Type": "text/html",
                     "Access-Control-Allow-Origin": config.origin,
                     "Access-Control-Allow-Methods": "GET,PATCH,PUT,DELETE",
@@ -393,22 +417,28 @@ async function buildRequestContext(req: Request, headers: Headers) {
 
     const authHeader = headers.get("authorization");
     const token = authHeader?.startsWith("Bearer ") ? authHeader.split(" ")[1] : authHeader;
-  
 
-    if (token) {  
-        context.principal = await context.services.Clover.Verify(token);
+
+    if (token) {
+        if (config.Clover_Tenant_ID) {
+            context.principal = await context.services.Verify(token);
+        } else {
+            const tokenValid = validateToken(token)
+            context.principal.isAuthenticated = tokenValid ? true : false
+        }
+
     }
 
     return context;
 }
 
- 
+
 // --- Initial Server Start --- 
 server = Bun.serve(await createServeConfig());
 console.log(`🚀 Hapta listening at http://localhost:${server.port}`);
 watchFiles();
- 
+
 export {
     DatabaseService,
     Context
-};
+};

package/package.json

@@ -3,7 +3,7 @@
   "bin": {
     "hapta":"./index.ts"
   },
-  "version": "1.0.2",
+  "version": "1.0.4",
   "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.2",

package/src/core/config.ts

@@ -36,7 +36,8 @@ function findAndLoadConfig(): AppConfig {
         if (fs.existsSync(localConfigPath)) {
             console.log(`Loading configuration from: ${localConfigPath}`);
             const fileContent = fs.readFileSync(localConfigPath, 'utf-8');
-            const userConfig = JSON.parse(fileContent); 
+            const userConfig = JSON.parse(fileContent);
+            console.log(userConfig)
             
             // Merge user config with defaults, so user only has to specify what they want to change
             return { ...defaultConfig, ...userConfig };

package/test_html/index.html

@@ -1,23 +0,0 @@
-<!DOCTYPE html>
-<html lang="en">
-<head>
-    <meta charset="UTF-8">
-    <meta name="viewport" content="width=device-width, initial-scale=1.0">
-    <title>Document</title>
-</head>
-<body>
-    <input type="text" placeholder="Username" id ="username" />
-    <input type="text" placeholder="Password" id="password" />
-    <button onclick="login()"></button>
-    <script> 
-        function login(){
-            
-        const username = document.getElementById("username").value
-        const password = document.getElementById("password").value
-                console.log(username,password)
-        }
-
-
-    </script>
-</body>
-</html>