wabe 0.6.9 → 0.6.11

package/README.md

@@ -1,75 +1,181 @@
 <p align="center">
-  <a href="https://wabe.dev"><img src="https://wabe.dev/assets/logo.png" alt="Wabe logo" height=170></a>
+  <h1 align="center">Wabe</h1>
+  <p align="center">🚀 A fully open-source <strong>Firebase alternative</strong> built in TypeScript</p>
 </p>
 
-<div align="center">
-  <a href="https://wabe.dev">Documentation</a>
-</div>
+<p align="center">
+  <a href="https://github.com/palixir/wabe"><img src="https://img.shields.io/github/stars/palixir/wabe?style=flat-square" /></a>
+  <a href="https://www.npmjs.com/package/wabe"><img src="https://img.shields.io/npm/v/wabe?style=flat-square" /></a>
+  <a href="./LICENSE"><img src="https://img.shields.io/badge/license-Apache--2.0-green?style=flat-square" /></a>
+</p>
+
+---
+
+Wabe is a modern, batteries-included backend-as-a-service designed for developers who want the flexibility of self-hosting with the ease of Firebase.
+
+You define your models → Wabe instantly generates:
+
+- a **secure GraphQL API**
+- **auth**, **permissions**, **hooks**, **emails**, **files**, and more
+- a fully extensible backend written in clean TypeScript
+
+No vendor lock-in. No hidden limits.  
+Host it anywhere.
+
+📚 **Documentation:** [https://palixir.github.io/wabe](https://palixir.github.io/wabe)
 
-## What is Wabe?
+---
 
-Wabe is an open-source backend as a service that allows you to create your own fully customizable backend in just a few minutes. It handles database access, automatic GraphQL API generation, authentication with various methods (classic or OAuth), permissions, security, emails, and more for you.
+# ✨ Features
 
-It requires Bun or Node > 24.7.
+| Feature                   | Description                                                                              |
+| ------------------------- | ---------------------------------------------------------------------------------------- |
+| 🔐 Authentication         | Email/password, OTP, OAuth (Google, GitHub), password reset, email verification          |
+| 🔑 Permissions            | Fine-grained access control at collection, object, and field levels with secure defaults |
+| ⚡ Auto-generated GraphQL | Fully typed CRUD GraphQL API generated from your schema, ready for production            |
+| 🔄 Hooks                  | Custom logic before/after create, update, delete, and read operations                    |
+| 📨 Email providers        | Resend (official adapter) or custom adapters                                             |
+| 🗄️ Database adapters      | MongoDB, PostgreSQL (official), or your own adapter                                      |
+| 📦 Modular architecture   | Replaceable and extensible modules: auth, storage, email, database, permissions          |
+| 🌍 Self-host anywhere     | Docker, Node, Bun, Fly.io, Render, Railway, Hetzner, Raspberry Pi                        |
 
-## Install
+---
 
-```sh
-bun install wabe # On bun
-npm install wabe # On npm
-yarn add wabe # On yarn
+# 🚀 Quickstart
+
+### 1. Install
+
+```bash
+npm install wabe
+# or
+bun add wabe
 ```
 
-## Basic example
+### 2. Create your schema and start your server
 
 ```ts
-import { Wabe } from "wabe";
-import { MongoAdapter } from "wabe-mongodb";
+import { Wabe } from 'wabe'
+import { MongoAdapter } from 'wabe-mongodb'
 
 const run = async () => {
-  // Ensure your database is running before run the file
-
-  const wabe = new Wabe({
-    isProduction: process.env.NODE_ENV === "production",
-    // Root key example (must be long minimal 64 characters, you can generate it online)
-    rootKey:
-      "0uwFvUxM$ceFuF1aEtTtZMa7DUN2NZudqgY5ve5W*QCyb58cwMj9JeoaV@d#%29v&aJzswuudVU1%nAT+rxS0Bh&OkgBYc0PH18*",
-    database: {
-      adapter: new MongoAdapter({
-        databaseName: "WabeApp",
-        databaseUrl: "mongodb://127.0.0.1:27045",
-      }),
-    },
-    port: 3001,
-  });
-
-  await wabe.start();
-};
-
-await run();
+	const wabe = new Wabe({
+		isProduction: process.env.NODE_ENV === 'production',
+		// Root key example (must be long minimal 64 characters, you can generate it online)
+		rootKey:
+			'0uwFvUxM$ceFuF1aEtTtZMa7DUN2NZudqgY5ve5W*QCyb58cwMj9JeoaV@d#%29v&aJzswuudVU1%nAT+rxS0Bh&OkgBYc0PH18*',
+		database: {
+			adapter: new MongoAdapter({
+				databaseName: 'WabeApp',
+				databaseUrl: 'mongodb://127.0.0.1:27045',
+			}),
+		},
+		schema: {
+			classes: [
+				{
+					name: 'User',
+					description: 'User class',
+					fields: {
+						name: {
+							type: 'String',
+						},
+						age: {
+							type: 'Int',
+						},
+						email: {
+							type: 'Email',
+							required: true,
+						},
+					},
+				},
+			],
+		},
+		port: 3000,
+	})
+
+	await wabe.start()
+}
+
+await run()
+```
+
+### 3. Query your API
+
+```graphql
+mutation createUser {
+	createUser(input: { fields: { name: "Wabe", email: "mybackend@wabe.com", age: 10 } }) {
+		user {
+			id
+			name
+		}
+	}
+}
 ```
 
-## Features
+# 🧩 Official Templates
+
+Wabe comes with a set of official templates to help you bootstrap projects instantly:
+
+| Template               | Stack          | Description                       | Status         |
+| ---------------------- | -------------- | --------------------------------- | -------------- |
+| **wabe-starter**       | Wabe + Node    | Minimal starter backend           | 🟡 Coming soon |
+| **wabe-next-template** | Next.js + Wabe | Authentication + CRUD boilerplate | 🟡 Coming soon |
+| **wabe-saas-kit**      | Wabe + Wobe    | SaaS starter kit with Stripe      | 🟡 Coming soon |
+
+More templates are added regularly based on community needs.
+
+---
+
+# 🌱 Ecosystem
+
+### **Wobe — Full-stack web framework**
+
+Wobe is a lightweight, TypeScript-first full-stack framework designed to pair naturally with Wabe.  
+For a seamless frontend + backend developer experience:
+
+👉 https://github.com/palixir/wobe
+
+### **GraphQL Server (coming soon)**
+
+A modern, type-safe GraphQL server designed as a companion to Wabe.  
+Optimized for DX, performance, and full extensibility.
+
+---
+
+# 🗺️ Roadmap
+
+- [x] PostgreSQL adapter
+- [ ] Admin dashboard UI
+- [x] File storage adapters (S3, Cloudflare R2, etc.)
+- [ ] CLI (`wabe init`, `wabe generate`)
+- [ ] SaaS starter kit
+- [ ] Improved documentation
+
+---
+
+# 🤝 Contributing
+
+Contributions are welcome!  
+Before opening a PR, check the `CONTRIBUTING.md` and join the community.
+
+---
 
-- **Authentication**: Secure and scalable authentication for your applications.
-- **Permissions**: Granular permissions control to secure your resources.
-- **Database**: A powerful, scalable database to store and manage you data.
-- **GraphQL API**: A flexible and powerful GraphQL API (following GraphQL Relay standard) to interact with your data.
-- **Hooks**: Powerful hooks system to execute custom actions before or after database requests.
-- **Email**: Send emails with your favorite provider with very simple integration.
+# ❤️ Sponsors
 
-## Contributing
+Wabe is 100% open-source and maintained in my free time.  
+If you want to support development:
 
-Contributions are always welcome! If you have an idea for something that should be added, modified, or removed, please don't hesitate to create a pull request (I promise a quick review).
+👉 **GitHub Sponsors:** https://github.com/sponsors/coratgerl
 
-You can also create an issue to propose your ideas or report a bug.
+**Sponsors receive:**
 
-Of course, you can also use Wabe for your backend; that is the better contribution at this day ❤️.
+- Access to a complete, fully tested boilerplate with an admin dashboard to manage users (Vite, Tailwind, Playwright, Wabe, Bun, GraphQL, etc.)
+- Your name featured in the `README.md`
 
-If you like the project don't forget to share it.
+Your support helps keep Wabe sustainable and actively maintained, and allows me to continue creating new projects in my free time to help developers have solid backends with minimal effort.
 
-More information on the [Contribution guide](https://github.com/palixir/wabe/blob/main/CONTRIBUTING.md)
+---
 
-## License
+# ⭐ Show your support
 
-Distributed under the Apache License 2.0 [License](https://github.com/palixir/wabe/blob/main/LICENSE).
+If you like the project, please consider starring the repository:
+⭐ → It helps more than you think.

package/bucket/b.txt

@@ -0,0 +1 @@
+b

package/dev/index.ts

@@ -0,0 +1,215 @@
+import {
+	RoleEnum,
+	type WabeSchemaWhereTypes,
+	type WabeSchemaEnums,
+	type WabeSchemaScalars,
+	type WabeSchemaTypes,
+} from '../generated/wabe'
+import { getDatabaseAdapter } from '../src/utils/testHelper'
+import { Wabe } from '../src/server'
+import { FileDevAdapter } from '../src'
+import { runDatabase } from 'wabe-mongodb-launcher'
+
+const run = async () => {
+	await runDatabase()
+
+	const wabe = new Wabe<{
+		types: WabeSchemaTypes
+		scalars: WabeSchemaScalars
+		enums: WabeSchemaEnums
+		where: WabeSchemaWhereTypes
+	}>({
+		isProduction: false,
+		codegen: {
+			enabled: true,
+			path: `${import.meta.dirname}/../generated/`,
+		},
+		rootKey: 'dev',
+		authentication: {
+			session: {
+				cookieSession: true,
+				jwtSecret: 'dev',
+				jwtTokenFields: {
+					id: true,
+				},
+			},
+			roles: ['Admin', 'Client'],
+			successRedirectPath: 'https://palixir.github.io/wabe/',
+			failureRedirectPath: 'https://palixir.github.io/wabe/',
+		},
+		database: {
+			// @ts-expect-error
+			adapter: await getDatabaseAdapter('Wabe'),
+		},
+		file: {
+			adapter: new FileDevAdapter(),
+		},
+		port: 3001,
+		schema: {
+			classes: [
+				{
+					name: 'User',
+					description: 'User class',
+					fields: {
+						name: {
+							type: 'String',
+						},
+						age: {
+							type: 'Int',
+						},
+						email: {
+							type: 'Email',
+							required: true,
+						},
+					},
+				},
+				{
+					name: 'Post',
+					fields: {
+						name: { type: 'String', required: true },
+						test2: { type: 'RoleEnum' },
+						test3: { type: 'Relation', class: 'User', required: true },
+						test4: { type: 'Pointer', class: 'User', required: true },
+						experiences: {
+							type: 'Array',
+							typeValue: 'Object',
+							object: {
+								name: 'Experience',
+								required: true,
+								fields: {
+									jobTitle: {
+										type: 'String',
+										required: true,
+									},
+									companyName: {
+										type: 'String',
+										required: true,
+									},
+									startDate: {
+										type: 'String',
+										required: true,
+									},
+									endDate: {
+										type: 'String',
+										required: true,
+									},
+									achievements: {
+										type: 'Array',
+										typeValue: 'String',
+									},
+								},
+							},
+						},
+					},
+					permissions: {
+						create: {
+							requireAuthentication: true,
+							authorizedRoles: [RoleEnum.Admin],
+						},
+					},
+				},
+			],
+			resolvers: {
+				queries: {
+					helloWorld: {
+						type: 'String',
+						description: 'Hello world description',
+						args: {
+							name: {
+								type: 'String',
+								required: true,
+							},
+						},
+						resolve: () => 'Hello World',
+					},
+				},
+				mutations: {
+					createMutation: {
+						type: 'Boolean',
+						required: true,
+						args: {
+							input: {
+								name: {
+									type: 'Int',
+									required: true,
+								},
+							},
+						},
+						resolve: () => true,
+					},
+					customMutation: {
+						type: 'Int',
+						args: {
+							input: {
+								a: {
+									type: 'Int',
+									required: true,
+								},
+								b: {
+									type: 'Int',
+									required: true,
+								},
+							},
+						},
+						resolve: (_: any, args: any) => args.input.a + args.input.b,
+					},
+					secondCustomMutation: {
+						type: 'Int',
+						args: {
+							input: {
+								sum: {
+									type: 'Object',
+									object: {
+										name: 'Sum',
+										fields: {
+											a: {
+												type: 'Int',
+												required: true,
+											},
+											b: {
+												type: 'Int',
+												required: true,
+											},
+										},
+									},
+								},
+							},
+						},
+						resolve: (_: any, args: any) => args.input.sum.a + args.input.sum.b,
+					},
+				},
+			},
+		},
+	})
+
+	// For select test
+	// const res = await wabe.controllers.database.getObjects({
+	//   className: 'Post',
+	//   context: {} as any,
+	//   select: {
+	//     name: true,
+	//     test3: {
+	//       age: true,
+	//       role: {
+	//         id: true,
+	//       },
+	//     },
+	//     test4: {
+	//       name: true,
+	//     },
+	//   },
+	//   where: {
+	//     name: {
+	//       equalTo: 'test',
+	//     },
+	//   },
+	// })
+
+	// res[0]?.test3[0].role?.id
+
+	await wabe.start()
+}
+
+run().catch((err) => {
+	console.error(err)
+})

package/dist/authentication/Session.d.ts

@@ -8,7 +8,10 @@ export declare class Session {
 	getAccessTokenExpireAt(config: WabeConfig<DevWabeTypes>);
 	_getRefreshTokenExpiresInMs(config: WabeConfig<DevWabeTypes>);
 	getRefreshTokenExpireAt(config: WabeConfig<DevWabeTypes>);
-	meFromAccessToken(accessToken: string, context: WabeContext<DevWabeTypes>): Promise<{
+	meFromAccessToken({ accessToken, csrfToken }: {
+		accessToken: string;
+		csrfToken: string;
+	}, context: WabeContext<DevWabeTypes>): Promise<{
 		sessionId: string | null;
 		user: User | null;
 		accessToken: string | null;

package/dist/authentication/interface.d.ts

@@ -101,6 +101,22 @@ export interface SessionConfig<T extends WabeTypes> {
 	*/
 	jwtSecret: string;
 	/**
+	* Optional audience to embed and verify in JWTs
+	*/
+	jwtAudience?: string;
+	/**
+	* Optional issuer to embed and verify in JWTs
+	*/
+	jwtIssuer?: string;
+	/**
+	* Secret dedicated to CSRF token HMAC (defaults to jwtSecret)
+	*/
+	csrfSecret?: string;
+	/**
+	* Secret used to encrypt session tokens at rest (defaults to jwtSecret)
+	*/
+	tokenSecret?: string;
+	/**
 	* A selection of fields to include in the JWT token in the "user" fields
 	*/
 	jwtTokenFields?: SelectType<T, "User", keyof T["types"]["User"]>;

package/dist/cron/index.d.ts

@@ -13,7 +13,6 @@ export declare enum CronExpressions {
 	EVERY_HOUR = "0 0 * * * *",
 	EVERY_DAY_AT_MIDNIGHT = "0 0 0 * * *",
 	EVERY_WEEK = "0 0 0 * * 0",
-	EVERY_MONTH = "0 0 0 1 * *",
 	EVERY_YEAR = "0 0 0 1 1 *",
 	WEEKDAYS_MORNING = "0 0 7 * * 1-5",
 	WEEKENDS_EVENING = "0 0 19 * * 6-7",

package/dist/database/DatabaseController.d.ts

@@ -1,4 +1,5 @@
 import type { WabeTypes } from "../..";
+import { OperationType } from "../hooks";
 import type { SchemaInterface } from "../schema";
 import type { WabeContext } from "../server/interface";
 import type { CountOptions, CreateObjectOptions, CreateObjectsOptions, DatabaseAdapter, DeleteObjectOptions, DeleteObjectsOptions, GetObjectOptions, GetObjectsOptions, OutputType, UpdateObjectOptions, UpdateObjectsOptions, WhereType } from "./interface";
@@ -7,32 +8,59 @@ type SelectWithObject = Record<string, object | boolean>;
 export declare class DatabaseController<T extends WabeTypes> {
 	adapter: DatabaseAdapter<T>;
 	constructor(adapter: DatabaseAdapter<T>);
+	/**
+	* Get a class definition from the schema by name (case-insensitive)
+	*/
+	_getClass(className: string | keyof T["types"], context: WabeContext<T>);
+	/**
+	* Get field type and target class information
+	*/
+	_getFieldType(originClassName: string, fieldName: string, context: WabeContext<T>): {
+		type: string;
+		class?: string;
+	} | undefined;
 	_getSelectMinusPointersAndRelations({ className, context, select }: {
 		className: keyof T["types"];
 		context: WabeContext<T>;
 		select?: SelectWithObject;
 	}): {
-		// We associated the fieldName with a className and a select object
 		pointers: Record<string, {
 			className: string;
 			select: Select;
 		}>;
 		selectWithoutPointers: Select;
 	};
-	_isRelationField({ pointerField, currentClassName, context, originClassName }: {
-		pointerField: string;
-		originClassName: string;
-		context: WabeContext<T>;
-		currentClassName?: string;
-	});
-	_isPointerField({ pointerField, currentClassName, context, originClassName }: {
-		originClassName: string;
-		context: WabeContext<T>;
-		pointerField: string;
-		currentClassName?: string;
-	});
+	_isFieldOfType(originClassName: string, pointerField: string, expectedType: "Pointer" | "Relation", context: WabeContext<T>, currentClassName?: string): boolean;
 	_getWhereObjectWithPointerOrRelation<U extends keyof T["types"]>(className: U, where: WhereType<T, U>, context: WabeContext<T>);
 	_buildWhereWithACL<K extends keyof T["types"]>(where: WhereType<T, K>, context: WabeContext<T>, operation: "write" | "read"): WhereType<T, K>;
+	/**
+	* Private helper to load a single object for hooks (skips hooks to avoid recursion)
+	*/
+	_loadObjectForHooks(className: keyof T["types"], context: WabeContext<T>): unknown;
+	/**
+	* Private helper to load multiple objects for hooks (skips hooks to avoid recursion)
+	*/
+	_loadObjectsForHooks(className: keyof T["types"], context: WabeContext<T>): unknown;
+	/**
+	* Generic executor for single object operations (create, update, delete, read)
+	* Encapsulates the hook lifecycle: Init -> Before -> Adapter -> After
+	*/
+	_executeSingleOperationWithHooks<
+		K extends keyof T["types"],
+		U extends keyof T["types"][K]
+	>({ operationTypeBefore, operationTypeAfter, className, context, data, select, id, adapterCallback, inputObject }: {
+		operationTypeBefore: OperationType;
+		operationTypeAfter: OperationType;
+		className: K;
+		context: WabeContext<T>;
+		data?: any;
+		select?: Select;
+		id?: string;
+		inputObject?: OutputType<T, K, U>;
+		adapterCallback: (newData: any) => Promise<OutputType<T, K, U> | {
+			id: string;
+		} | null>;
+	});
 	_getFinalObjectWithPointerAndRelation({ pointers, context, originClassName, object, _skipHooks }: {
 		originClassName: string;
 		pointers: Record<string, {

package/dist/database/interface.d.ts

@@ -28,6 +28,7 @@ type WhereScalar<T> = {
 	notIn?: T[];
 	contains?: T;
 	notContains?: T;
+	exists?: boolean;
 };
 type WhereObject<T> = { [P in keyof T] : IsScalar<T[P]> extends false ? WhereObject<Partial<T[P]>> : WhereScalar<T[P]> };
 type WhereAggregation<

package/dist/email/DevAdapter.d.ts

@@ -1,5 +1,4 @@
 import type { EmailAdapter } from "./interface";
 export declare class EmailDevAdapter implements EmailAdapter {
-	// biome-ignore lint/suspicious/useAwait: false
 	send();
 }

package/dist/email/interface.d.ts

@@ -10,7 +10,7 @@ export interface EmailSendOptions {
 	from: string;
 	to: Array<string>;
 	subject: string;
-	node?: React.ReactNode;
+	node?: any;
 	html?: string;
 	text?: string;
 }

package/dist/graphql/resolvers.d.ts

@@ -1,6 +1,8 @@
-import type { SelectionSetNode } from "graphql";
+import type { SelectionSetNode, FragmentDefinitionNode } from "graphql";
 import type { WabeContext } from "../server/interface";
-export declare const extractFieldsFromSetNode: (selectionSet: SelectionSetNode, className: string) => Record<string, any>;
+export declare const extractFieldsFromSetNode: (selectionSet: SelectionSetNode, className: string, fragments?: Record<string, FragmentDefinitionNode>, options?: {
+	ignoreClassField?: boolean;
+}) => Record<string, any>;
 export declare const getFieldsOfClassName: ({ fields, className, context }: {
 	fields: string[];
 	className: string;

package/dist/hooks/index.d.ts

@@ -1,4 +1,4 @@
-import type { MutationData, OutputType, Select } from "../database";
+import type { MutationData, OutputType, Select, WhereType } from "../database";
 import type { WabeTypes } from "../server";
 import type { WabeContext } from "../server/interface";
 import type { DevWabeTypes } from "../utils/helper";
@@ -30,16 +30,22 @@ export declare const _findHooksByPriority: unknown;
 export declare const initializeHook: <
 	T extends WabeTypes,
 	K extends keyof T["types"]
->({ className, newData, context, select }: {
+>({ className, newData, context, select, objectLoader, objectsLoader }: {
 	className: K;
 	newData?: MutationData<DevWabeTypes, any, any>;
 	select: Select;
 	context: WabeContext<any>;
+	objectLoader?: (id: string) => Promise<OutputType<DevWabeTypes, any, any> | null>;
+	objectsLoader?: (opts: {
+		where?: WhereType<DevWabeTypes, any>;
+		ids: string[];
+	}) => Promise<OutputType<DevWabeTypes, any, any>[]>;
 }) => {
 	runOnSingleObject: (options: {
 		operationType: OperationType;
 		id?: string;
 		originalObject?: OutputType<DevWabeTypes, any, any>;
+		object?: OutputType<DevWabeTypes, any, any>;
 	}) => Promise<MutationData<T, K, any>>;
 };
 export declare const getDefaultHooks: () => Hook<any, any>[];

package/dist/index.d.ts

@@ -5,6 +5,5 @@ export * from "./database";
 export * from "./authentication";
 export * from "./file";
 export * from "./email";
-export * from "./ai";
 export * from "./utils/export";
 export * from "./cron";