@kadirgun/lucid-bravo 0.0.9 → 0.1.1

package/README.md

@@ -37,15 +37,15 @@ export default class PostBravo extends LucidBravo<ModelType> {
   protected model = Post
   protected defaultLimit = 10
 
-  public override getSortable(): LucidBravoAttributes<ModelType>[] {
+  protected override getSortable(): LucidBravoAttributes<ModelType>[] {
     return ['id', 'title']
   }
 
-  public override getAllowedIncludes(): LucidBravoRelations<Post>[] {
+  protected override getAllowedIncludes(): LucidBravoRelations<Post>[] {
     return ['labels']
   }
 
-  public async title(value: string) {
+  protected async title(value: string) {
     this.$query.where('title', 'like', `%${value}%`)
   }
 }

package/build/index.js

@@ -9,29 +9,21 @@ var LucidBravo = class {
 	$params;
 	$http;
 	$countQuery;
+	$filteredQuery;
+	applied = false;
 	defaultLimit = 20;
 	defaultSort = null;
 	constructor(params, query) {
 		this.$params = params || {};
 		this.$http = HttpContext.getOrFail();
-		if (query) {
-			this.model = query.model;
-			this.$query = query;
-			this.$countQuery = this.$query.clone();
-		}
+		if (query) this.$query = query;
+		else this.$query = this.getModel().query();
+		this.model = this.$query.model;
+		this.$countQuery = this.$query.clone();
 	}
 	static build(params, query) {
 		return new this(params, query);
 	}
-	resolveQuery() {
-		if (this.$query) return this.$query;
-		if (this.model) {
-			this.$query = this.model.query();
-			this.$countQuery = this.$query.clone();
-			return this.$query;
-		}
-		throw new Error("Either a query must be provided or $model must be set in the subclass");
-	}
 	/**
 	* Return a whitelist of sortable columns
 	*/
@@ -44,33 +36,37 @@ var LucidBravo = class {
 	getAllowedIncludes() {
 		return [];
 	}
+	getModel() {
+		if (this.model) return this.model;
+		throw new Error("Model not defined");
+	}
 	/**
 	* Main entry point to apply all filters, includes, sorting and pagination
 	*/
 	async apply() {
-		this.resolveQuery();
+		if (this.applied) return this.$query;
 		await this.applyFilters();
 		await this.applyIncludes();
 		await this.applySorting();
 		await this.applyPagination();
+		this.applied = true;
 		return this.$query;
 	}
-	async count() {
-		this.resolveQuery();
-		const result = await this.$countQuery.count("* as total").firstOrFail();
+	async count(query) {
+		const result = await query.count("* as total").firstOrFail();
 		return Number(result.$extras.total);
 	}
 	async paginate() {
 		return {
 			items: await this.apply(),
-			total: await this.count()
+			total: await this.count(this.$countQuery),
+			filtered: await this.count(this.$filteredQuery)
 		};
 	}
 	/**
 	* Automatically call methods that match camelCase version of snake_case params
 	*/
 	async applyFilters() {
-		this.resolveQuery();
 		for (const [key, value] of Object.entries(this.$params)) {
 			if ([
 				"page",
@@ -84,25 +80,24 @@ var LucidBravo = class {
 			if (typeof method !== "function") throw new Error(`Expected ${methodName} to be a method on ${this.constructor.name}`);
 			await method.call(this, value);
 		}
+		this.$filteredQuery = this.$query.clone();
 	}
 	/**
 	* Apply preload include relations based on allowlist
 	*/
 	async applyIncludes() {
-		const query = this.resolveQuery();
 		const includes = this.$params.include;
 		if (!Array.isArray(includes) || includes.length === 0) return;
 		const allowed = this.getAllowedIncludes();
 		for (const relation of includes) {
 			if (!allowed.includes(relation)) continue;
-			query.preload(relation);
+			this.$query.preload(relation);
 		}
 	}
 	/**
 	* Apply sorting based on sort[field] and sort[order] params
 	*/
 	async applySorting() {
-		const query = this.resolveQuery();
 		const sort = this.$params.sort;
 		const sortable = this.getSortable();
 		let field = sort?.field;
@@ -111,16 +106,12 @@ var LucidBravo = class {
 			field = this.defaultSort.field;
 			order = this.defaultSort.order;
 		}
-		if (field && sortable.includes(field)) query.orderBy(field, order);
+		if (field && sortable.includes(field)) this.$query.orderBy(field, order);
 	}
-	/**
-	* Apply simple limit and offset pagination
-	*/
 	async applyPagination() {
-		const query = this.resolveQuery();
 		const limit = Number(this.$params.limit) || this.defaultLimit;
 		const offset = ((Number(this.$params.page) || 1) - 1) * limit;
-		if (limit > 0) query.limit(limit).offset(offset);
+		if (limit > 0) this.$query.limit(limit).offset(offset);
 	}
 };
 //#endregion

package/build/src/lucid_bravo.d.ts

@@ -1,34 +1,37 @@
 import type { LucidModel, ModelQueryBuilderContract } from '@adonisjs/lucid/types/model';
-import type { BravoParams, BravoSortOption, LucidBravoRelations, LucidBravoAttributes } from './types.ts';
 import { HttpContext } from '@adonisjs/core/http';
 import type { Constructor } from '@adonisjs/core/types/common';
+import type { BravoParams, BravoSortOption, LucidBravoAttributes, LucidBravoRelations } from './types.ts';
 export declare abstract class LucidBravo<T extends LucidModel> {
-    protected model?: T;
+    private model;
     protected $query: ModelQueryBuilderContract<T>;
     protected $params: BravoParams;
     protected $http: HttpContext;
     protected $countQuery: ModelQueryBuilderContract<T>;
+    protected $filteredQuery: ModelQueryBuilderContract<T>;
+    private applied;
     protected defaultLimit: number;
     protected defaultSort: BravoSortOption | null;
     constructor(params?: BravoParams, query?: ModelQueryBuilderContract<T>);
     static build<T extends LucidModel, B extends LucidBravo<T>>(this: Constructor<B>, params?: BravoParams, query?: ModelQueryBuilderContract<T>): B;
-    protected resolveQuery(): ModelQueryBuilderContract<T, InstanceType<T>>;
     /**
      * Return a whitelist of sortable columns
      */
-    getSortable(): LucidBravoAttributes<T>[];
+    protected getSortable(): LucidBravoAttributes<T>[];
     /**
      * Return a whitelist of allowed relations for preload include
      */
-    getAllowedIncludes(): LucidBravoRelations<InstanceType<T>>[];
+    protected getAllowedIncludes(): LucidBravoRelations<InstanceType<T>>[];
+    protected getModel(): T;
     /**
      * Main entry point to apply all filters, includes, sorting and pagination
      */
     apply(): Promise<InstanceType<T>[]>;
-    count(): Promise<number>;
+    private count;
     paginate(): Promise<{
         items: InstanceType<T>[];
         total: number;
+        filtered: number;
     }>;
     /**
      * Automatically call methods that match camelCase version of snake_case params
@@ -42,8 +45,5 @@ export declare abstract class LucidBravo<T extends LucidModel> {
      * Apply sorting based on sort[field] and sort[order] params
      */
     protected applySorting(): Promise<void>;
-    /**
-     * Apply simple limit and offset pagination
-     */
     protected applyPagination(): Promise<void>;
 }

package/build/stubs/make/bravos/main.stub

@@ -14,14 +14,17 @@ import {{ entity.name }} from '{{ modelImportPath }}'
 type ModelType = typeof {{ entity.name }}
 
 export default class {{ modelName }}Bravo extends LucidBravo<ModelType> {
-  protected model = {{ entity.name }}
   protected defaultLimit = 20
 
-  public override getSortable(): LucidBravoAttributes<ModelType>[] {
+  protected getModel(): ModelType {
+    return {{ modelName }}
+  }
+
+  protected override getSortable(): LucidBravoAttributes<ModelType>[] {
     return []
   }
 
-  public override getAllowedIncludes(): LucidBravoRelations<{{ entity.name }}>[] {
+  protected override getAllowedIncludes(): LucidBravoRelations<{{ entity.name }}>[] {
     return []
   }
 }

package/build/validators/index.d.ts

@@ -0,0 +1 @@
+export { bravoSchema, bravoValidator } from './bravo.ts';