wabe 0.6.3 → 0.6.5

package/dist/payment/DevAdapter.d.ts

@@ -0,0 +1,17 @@
+import type { PaymentAdapter } from "./interface";
+export declare class PaymentDevAdapter implements PaymentAdapter {
+	adapter: {};
+	getCustomerById();
+	deleteCoupon();
+	updatePromotionCode();
+	createCoupon();
+	createPromotionCode();
+	validateWebhook();
+	createCustomer();
+	createPayment();
+	cancelSubscription();
+	getInvoices();
+	getTotalRevenue();
+	getAllTransactions();
+	getHypotheticalSubscriptionRevenue();
+}

package/dist/payment/PaymentController.d.ts

@@ -0,0 +1,19 @@
+import type { CancelSubscriptionOptions, CreateCustomerOptions, CreatePaymentOptions, GetInvoicesOptions, PaymentAdapter, PaymentConfig, GetTotalRevenueOptions, GetAllTransactionsOptions, GetCustomerByIdOptions, CreateCouponOptions, CreatePromotionCodeOptions, DeleteCouponOptions, UpdatePromotionCodeOptions } from "./interface";
+export declare class PaymentController implements PaymentAdapter {
+	adapter: PaymentAdapter;
+	private config;
+	constructor(paymentConfig: PaymentConfig);
+	deleteCoupon(options: DeleteCouponOptions);
+	updatePromotionCode(options: UpdatePromotionCodeOptions);
+	createCoupon(options: CreateCouponOptions);
+	createPromotionCode(options: CreatePromotionCodeOptions);
+	getCustomerById(options: GetCustomerByIdOptions);
+	validateWebhook(ctx: any);
+	createCustomer(options: CreateCustomerOptions);
+	createPayment(options: Omit<CreatePaymentOptions, "currency" | "paymentMethod">);
+	cancelSubscription(options: CancelSubscriptionOptions);
+	getInvoices(options: GetInvoicesOptions);
+	getTotalRevenue(options: GetTotalRevenueOptions);
+	getAllTransactions(options: GetAllTransactionsOptions);
+	getHypotheticalSubscriptionRevenue();
+}

package/dist/payment/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./interface";
+export * from "./DevAdapter";

package/dist/payment/interface.d.ts

@@ -0,0 +1,235 @@
+import type { Context } from "wobe";
+export declare enum Currency {
+	EUR = "eur",
+	USD = "usd",
+}
+export type Address = {
+	city: string
+	country: string
+	line1: string
+	line2: string
+	postalCode: string
+	state: string
+};
+export declare enum PaymentMode {
+	payment = "payment",
+	subscription = "subscription",
+}
+export type PaymentMethod = "card" | "paypal" | "link" | "sepa_debit" | "revolut_pay" | "us_bank_account";
+export declare enum PaymentReccuringInterval {
+	Month = "month",
+	Year = "year",
+}
+export type Product = {
+	name: string
+	unitAmount: number
+	quantity: number
+};
+export interface OnPaymentSucceedOptions {
+	createdAt: number;
+	amount: number;
+	customerEmail: string | null;
+	currency: string;
+	paymentMethodTypes: Array<string>;
+}
+export interface OnPaymentFailedOptions {
+	createdAt: number;
+	amount: number;
+	paymentMethodTypes: Array<string>;
+}
+/**
+* PaymentConfig
+* @property adapter - The payment adapter
+* @property supportedPaymentMethods - The supported payment methods
+* @property currency - The currency
+*/
+export interface PaymentConfig {
+	adapter: PaymentAdapter;
+	supportedPaymentMethods: Array<PaymentMethod>;
+	currency: Currency;
+}
+export type Invoice = {
+	amountDue: number
+	amountPaid: number
+	currency: Currency
+	id: string
+	created: number
+	invoiceUrl: string
+	isPaid: boolean
+};
+export type Transaction = {
+	customerEmail: string
+	amount: number
+	currency: Currency
+	created: number
+	isSubscription: boolean
+	reccuringInterval?: "month" | "year"
+};
+export type CreateCustomerOptions = {
+	customerName?: string
+	customerEmail: string
+	customerPhone?: string
+	address: Address
+	paymentMethod: PaymentMethod
+};
+export type CreatePaymentOptions = {
+	currency: Currency
+	customerEmail?: string
+	products: Array<Product>
+	paymentMethod: Array<PaymentMethod>
+	paymentMode: PaymentMode
+	successUrl: string
+	cancelUrl: string
+	automaticTax?: boolean
+	recurringInterval?: "month" | "year"
+	createInvoice?: boolean
+	allowPromotionCode?: boolean
+	promotionCodeId?: string
+	couponCodeId?: string
+};
+export type InitWebhookOptions = {
+	webhookUrl: string
+};
+export type CancelSubscriptionOptions = {
+	email: string
+};
+export type GetInvoicesOptions = {
+	email: string
+};
+export type GetTotalRevenueOptions = {
+	startRangeTimestamp?: number
+	endRangeTimestamp?: number
+	charge: "net" | "gross"
+};
+export type GetAllTransactionsOptions = {
+	startRangeTimestamp?: number
+	endRangeTimestamp?: number
+	first?: number
+};
+export type GetCustomerByIdOptions = {
+	id: string
+};
+export type ValidateWebhookOptions = {
+	ctx: Context
+	endpointSecret: string
+};
+/**
+* ValidateWebhookOutput
+* @property valid - Whether the webhook is valid or not
+* @property payload - The payload of the webhook
+*/
+export type ValidateWebhookOutput = {
+	isValid: boolean
+	type: string
+	payload: any | null
+};
+export type InitWebhookOutput = {
+	webhookId: string
+	endpointSecret: string
+};
+export type CreateCouponOptions = {
+	amountOff?: number
+	currency?: Currency
+	duration?: "forever" | "once" | "repeating"
+	durationInMonths?: number
+	name?: string
+	percentOff?: number
+	maxRedemptions?: number
+};
+export type CreatePromotionCodeOptions = {
+	couponId: string
+	code?: string
+	active?: boolean
+	maxRedemptions?: number
+};
+export type DeleteCouponOptions = {
+	id: string
+};
+export type UpdatePromotionCodeOptions = {
+	id: string
+	active: boolean
+};
+export interface PaymentAdapter {
+	/**
+	* Delete a coupon
+	* @param options DeleteCouponOptions
+	*/
+	deleteCoupon: (options: DeleteCouponOptions) => Promise<void>;
+	/**
+	* Create a coupon
+	* @param options CreateCouponOptions
+	* @returns id The coupon id
+	*/
+	createCoupon: (options: CreateCouponOptions) => Promise<{
+		code: string
+		id: string
+	}>;
+	/**
+	* Disable a promotion code
+	* @param options DeletePromotionCodeOptions
+	*/
+	updatePromotionCode: (options: UpdatePromotionCodeOptions) => Promise<void>;
+	/**
+	* Create a promotion code from a coupon
+	* @param options CreatePromotionCodeOptions
+	* @returns code, id The promotion code and the stripe id
+	*/
+	createPromotionCode: (options: CreatePromotionCodeOptions) => Promise<{
+		id: string
+		code: string
+	}>;
+	/**
+	* Get a customer by id
+	* @param id The customer id
+	* @returns The customer
+	*/
+	getCustomerById: (options: GetCustomerByIdOptions) => Promise<{
+		email: string | null
+	}>;
+	/**
+	* Create a customer
+	* @param options CreateCustomerOptions
+	* @returns The customer email
+	*/
+	createCustomer: (options: CreateCustomerOptions) => Promise<string>;
+	/**
+	* Create a payment
+	* @param options CreatePaymentOptions
+	* @returns The payment url
+	*/
+	createPayment: (options: CreatePaymentOptions) => Promise<string>;
+	/**
+	* Cancel a subscription
+	* @param options The customer email to cancel the subscription
+	*/
+	cancelSubscription: (options: CancelSubscriptionOptions) => Promise<void>;
+	/**
+	* Get invoices
+	* @param options The customer email to get the invoices
+	* @returns The invoices of a customer
+	*/
+	getInvoices: (options: GetInvoicesOptions) => Promise<Invoice[]>;
+	/**
+	* Get total revenue
+	* @param options The type of charge (net or gross) and the start and end range timestamps to get the total revenue
+	* @returns The total amount
+	*/
+	getTotalRevenue: (options: GetTotalRevenueOptions) => Promise<number>;
+	/**
+	* Get the list of all transactions
+	* @param options The start and end range timestamps to get the transactions
+	* @returns The list of transactions
+	*/
+	getAllTransactions: (options: GetAllTransactionsOptions) => Promise<Transaction[]>;
+	/**
+	* Get the hypothetical revenue of subscriptions
+	* @returns The hypothetical revenue of subscriptions
+	*/
+	getHypotheticalSubscriptionRevenue: () => Promise<number>;
+	/**
+	* Check if the request on webhook is from a valid provier
+	* @param ctx The Wobe context of the request
+	* @returns True if the request is from a valid provider, false otherwise
+	*/
+	validateWebhook: (options: ValidateWebhookOptions) => Promise<ValidateWebhookOutput>;
+}

package/dist/schema/Schema.d.ts

@@ -0,0 +1,164 @@
+import type { WabeConfig, WabeTypes } from "../server";
+import type { HookObject } from "../hooks/HookObject";
+export type WabePrimaryTypes = "String" | "Int" | "Float" | "Boolean" | "Email" | "Phone" | "Date" | "File";
+export type WabeCustomTypes = "Array" | "Object";
+export type WabeRelationTypes = "Pointer" | "Relation";
+type WabeFieldTypes = WabeCustomTypes | WabePrimaryTypes | WabeRelationTypes;
+export type WabeObject<T extends WabeTypes> = {
+	name: string
+	fields: SchemaFields<T>
+	description?: string
+	required?: boolean
+};
+type FieldBase<T extends WabeTypes> = {
+	required?: boolean
+	description?: string
+	protected?: {
+		authorizedRoles: Array<T["enums"]["RoleEnum"] | "rootOnly">
+		protectedOperations: Array<"create" | "read" | "update">
+	}
+};
+type TypeFieldBase<
+	U,
+	K extends WabeFieldTypes
+> = {
+	type: K
+	defaultValue?: U
+};
+type TypeFieldArray<T extends WabeTypes> = {
+	type: "Array"
+	requiredValue?: boolean
+	defaultValue?: any[]
+} & ({
+	typeValue: WabePrimaryTypes
+} | {
+	typeValue: "Object"
+	object: WabeObject<T>
+});
+type TypeFieldObject<T extends WabeTypes> = {
+	type: "Object"
+	object: WabeObject<T>
+	defaultValue?: any
+};
+type TypeFieldPointer<T extends WabeTypes> = {
+	type: "Pointer"
+	class: keyof T["types"]
+};
+type TypeFieldRelation<T extends WabeTypes> = {
+	type: "Relation"
+	class: keyof T["types"]
+};
+type TypeFieldFile = {
+	type: "File"
+};
+type TypeFieldCustomScalars<T extends WabeTypes> = {
+	type: T["scalars"]
+	required?: boolean
+	defaultValue?: any
+};
+type TypeFieldCustomEnums<T extends WabeTypes> = {
+	type: keyof T["enums"]
+	defaultValue?: any
+};
+export type TypeField<T extends WabeTypes> = (TypeFieldBase<string, "String"> | TypeFieldBase<number, "Int"> | TypeFieldBase<number, "Float"> | TypeFieldBase<boolean, "Boolean"> | TypeFieldBase<Date, "Date"> | TypeFieldBase<string, "Email"> | TypeFieldBase<string, "Phone"> | TypeFieldArray<T> | TypeFieldObject<T> | TypeFieldPointer<T> | TypeFieldRelation<T> | TypeFieldFile | TypeFieldCustomScalars<T> | TypeFieldCustomEnums<T>) & FieldBase<T>;
+export type SchemaFields<T extends WabeTypes> = Record<string, TypeField<T>>;
+export type ResolverType<T extends WabeTypes> = {
+	required?: boolean
+	description?: string
+	resolve: (...args: any) => any
+} & ({
+	type: WabePrimaryTypes | T["enums"] | T["scalars"]
+} | {
+	type: "Object"
+	outputObject: ClassInterface<T>
+} | {
+	type: "Array"
+	typeValue: WabePrimaryTypes
+	typeValueRequired?: boolean
+} | {
+	type: "Array"
+	typeValue: "Object"
+	outputObject: ClassInterface<T>
+	typeValueRequired?: boolean
+});
+export type QueryResolver<T extends WabeTypes> = {
+	args?: SchemaFields<T>
+} & ResolverType<T>;
+export type MutationResolver<T extends WabeTypes> = {
+	args?: {
+		input: SchemaFields<T>
+	}
+} & ResolverType<T>;
+export type TypeResolver<T extends WabeTypes> = {
+	queries?: {
+		[key: string]: QueryResolver<T>
+	}
+	mutations?: {
+		[key: string]: MutationResolver<T>
+	}
+};
+export type PermissionsOperations = "create" | "read" | "update" | "delete";
+export interface PermissionProperties<T extends WabeTypes> {
+	requireAuthentication?: boolean;
+	/**
+	* An empty array means that none role is authorized (except root client)
+	*/
+	authorizedRoles?: Array<T["enums"]["RoleEnum"] | "everyone">;
+}
+/**
+* ACL properties
+* Callback to define the ACL object before insert of the object in the database
+* Can be done with a beforeCreate hook but for simplicity we can define it here
+*/
+export type ACLProperties = (hookObject: HookObject<any, any>) => void | Promise<void>;
+export type ClassPermissions<T extends WabeTypes> = Partial<Record<PermissionsOperations, PermissionProperties<T>> & {
+	acl: ACLProperties
+}>;
+export type SearchableFields = Array<string>;
+export type ClassIndexes = Array<{
+	field: string
+	order: "ASC" | "DESC"
+	unique?: boolean
+}>;
+export interface ClassInterface<T extends WabeTypes> {
+	name: string;
+	fields: SchemaFields<T>;
+	description?: string;
+	permissions?: ClassPermissions<T>;
+	searchableFields?: SearchableFields;
+	indexes?: ClassIndexes;
+}
+export interface ScalarInterface {
+	name: string;
+	description?: string;
+	parseValue?: (value: any) => any;
+	serialize?: (value: any) => any;
+	parseLiteral?: (ast: any) => any;
+}
+export interface EnumInterface {
+	name: string;
+	values: Record<string, string>;
+	description?: string;
+}
+export interface SchemaInterface<T extends WabeTypes> {
+	classes?: ClassInterface<T>[];
+	scalars?: ScalarInterface[];
+	enums?: EnumInterface[];
+	resolvers?: TypeResolver<T>;
+}
+export declare class Schema<T extends WabeTypes> {
+	schema: SchemaInterface<T>;
+	private config;
+	constructor(config: WabeConfig<T>);
+	defaultEnum(): EnumInterface[];
+	mergeResolvers(defaultResolvers: TypeResolver<T>): TypeResolver<T>;
+	defaultResolvers(): TypeResolver<T>;
+	sessionClass(): ClassInterface<T>;
+	roleClass(): ClassInterface<T>;
+	internalConfigClass(): ClassInterface<T>;
+	userClass(): ClassInterface<T>;
+	defaultFields(): SchemaFields<T>;
+	mergeClass(newClass: ClassInterface<T>[]): ClassInterface<T>[];
+	defaultClass(schema?: SchemaInterface<T>): ClassInterface<T>[];
+}
+export {};

package/dist/schema/defaultResolvers.d.ts

@@ -0,0 +1,7 @@
+import type { MutationResolver, QueryResolver } from "./Schema";
+export declare const defaultQueries: {
+	[key: string]: QueryResolver<any>
+};
+export declare const defaultMutations: {
+	[key: string]: MutationResolver<any>
+};

package/dist/schema/index.d.ts

@@ -0,0 +1 @@
+export * from "./Schema";

package/dist/schema/resolvers/meResolver.d.ts

@@ -0,0 +1 @@
+export declare const meResolver: unknown;

package/dist/schema/resolvers/resetPassword.d.ts

@@ -0,0 +1 @@
+export declare const resetPasswordResolver: unknown;

package/dist/schema/resolvers/sendEmail.d.ts

@@ -0,0 +1 @@
+export declare const sendEmailResolver: unknown;

package/dist/schema/resolvers/sendOtpCode.d.ts

@@ -0,0 +1 @@
+export declare const sendOtpCodeResolver: unknown;

package/dist/server/defaultHandlers.d.ts

@@ -0,0 +1 @@
+export declare const defaultSessionHandler: unknown;

package/dist/server/generateCodegen.d.ts

@@ -0,0 +1 @@
+export declare const generateCodegen: unknown;

package/dist/server/index.d.ts

@@ -0,0 +1,77 @@
+import type { DatabaseConfig } from "../database";
+import { DatabaseController } from "../database/controllers/DatabaseController";
+import { type SchemaInterface } from "../schema/Schema";
+import { GraphQLSchema } from "graphql";
+import type { AuthenticationConfig } from "../authentication/interface";
+import { type WabeRoute } from "./routes";
+import { type Hook } from "../hooks";
+import { generateCodegen } from "./generateCodegen";
+import { Wobe } from "wobe";
+import type { Context, CorsOptions, RateLimitOptions } from "wobe";
+import type { WabeContext } from "./interface";
+import type { FileConfig } from "../files";
+import type { EmailConfig } from "../email";
+import { EmailController } from "../email/EmailController";
+import type { PaymentConfig } from "../payment/interface";
+import { PaymentController } from "../payment/PaymentController";
+import type { AIConfig } from "../ai";
+import { FileController } from "../files/FileController";
+import type { CronConfig } from "../cron";
+type SecurityConfig = {
+	corsOptions?: CorsOptions
+	rateLimit?: RateLimitOptions
+	maskErrorMessage?: boolean
+};
+export interface WabeConfig<T extends WabeTypes> {
+	port: number;
+	isProduction: boolean;
+	hostname?: string;
+	security?: SecurityConfig;
+	schema?: SchemaInterface<T>;
+	graphqlSchema?: GraphQLSchema;
+	database: DatabaseConfig;
+	codegen?: {
+		enabled: true
+		path: string
+	} | {
+		enabled?: false
+	};
+	authentication?: AuthenticationConfig<T>;
+	routes?: WabeRoute[];
+	rootKey: string;
+	hooks?: Hook<T, any>[];
+	email?: EmailConfig;
+	payment?: PaymentConfig;
+	ai?: AIConfig;
+	file?: FileConfig;
+	crons?: CronConfig<T>;
+}
+export type WabeTypes = {
+	types: Record<any, any>
+	where: Record<any, any>
+	scalars: string
+	enums: Record<any, any>
+};
+export type WobeCustomContext<T extends WabeTypes> = Context & {
+	wabe: WabeContext<T>
+};
+type WabeControllers<T extends WabeTypes> = {
+	database: DatabaseController<T>
+	email?: EmailController
+	payment?: PaymentController
+	file?: FileController
+};
+export declare class Wabe<T extends WabeTypes> {
+	server: Wobe<WobeCustomContext<T>>;
+	config: WabeConfig<T>;
+	controllers: WabeControllers<T>;
+	constructor({ isProduction, port, hostname, security, schema, database, authentication, rootKey, codegen, hooks, file, email, payment, routes, crons }: WabeConfig<T>);
+	loadCrons();
+	loadRoleEnum();
+	loadAuthenticationMethods();
+	loadHooks();
+	loadRoutes();
+	start();
+	close();
+}
+export { generateCodegen };

package/dist/server/routes/authHandler.d.ts

@@ -0,0 +1,2 @@
+export declare const oauthHandlerCallback: unknown;
+export declare const authHandler: unknown;

package/dist/server/routes/index.d.ts

@@ -0,0 +1,8 @@
+import { type WobeHandler } from "wobe";
+import type { WobeCustomContext } from "..";
+export interface WabeRoute {
+	method: "GET" | "POST" | "PUT" | "DELETE";
+	path: string;
+	handler: WobeHandler<WobeCustomContext<any>>;
+}
+export declare const defaultRoutes: (devDirectory: string) => WabeRoute[];

package/dist/utils/export.d.ts

@@ -0,0 +1,2 @@
+import type { WabeContext } from "../server/interface";
+export declare const contextWithRoot: (context: WabeContext<any>) => WabeContext<any>;

package/dist/utils/helper.d.ts

@@ -0,0 +1,21 @@
+import { GraphQLClient } from "graphql-request";
+import { type WabeSchemaWhereTypes, type WabeSchemaEnums, type WabeSchemaScalars, type WabeSchemaTypes } from "../../generated/wabe";
+import { Wabe, type WabeTypes } from "../server";
+export interface DevWabeTypes extends WabeTypes {
+	types: WabeSchemaTypes;
+	scalars: WabeSchemaScalars;
+	enums: WabeSchemaEnums;
+	where: WabeSchemaWhereTypes;
+}
+export declare const firstLetterUpperCase: (str: string) => string;
+export declare const notEmpty: <T>(value: T | null | undefined) => value is T;
+export declare const getGraphqlClient: (port: number) => GraphQLClient;
+export declare const getAnonymousClient: (port: number) => GraphQLClient;
+export declare const getUserClient: (port: number, accessToken: string) => GraphQLClient;
+export declare const getAdminUserClient: (port: number, wabe: Wabe<DevWabeTypes>, { email, password }: {
+	email: string
+	password: string
+}) => Promise<GraphQLClient>;
+export declare const setupTests: unknown;
+export declare const closeTests: unknown;
+export declare const createUserAndUpdateRole: unknown;

package/dist/utils/index.d.ts

@@ -0,0 +1,17 @@
+import type { ClassInterface } from "../schema";
+import type { WabeTypes, WabeConfig } from "../server";
+export declare const firstLetterInUpperCase: unknown;
+export declare const firstLetterInLowerCase: unknown;
+export declare const getClassFromClassName: <T extends WabeTypes>(className: string, config: WabeConfig<any>) => ClassInterface<T>;
+export declare const getCookieInRequestHeaders: unknown;
+/**
+* This apply the following transformations on string:
+* - lowercase
+* - normalize with NFD
+* - remove diacritics and accents characters
+* - replace matching abbreviation with long version (if disableAbbrevations is not set)
+* - replace 2 or more spaces by one
+* - replace all non alpha characters by a space
+* - trim
+*/
+export declare const tokenize: unknown;