bradb 1.2.4 → 1.3.0

package/dist/src/controller.d.ts

@@ -1,16 +1,27 @@
 import { PgTable } from "drizzle-orm/pg-core";
 import { Request, Response } from "express";
 import { z, ZodObject } from "zod";
-import { CreateService, DeleteService, UpdateService, FindOneService, RetrieverService, Filter } from "./types";
-export declare function findOneBuilder<TTable extends PgTable>(service: FindOneService<TTable>, hook?: (item: TTable["$inferSelect"]) => Response): (req: Request, res: Response) => Promise<Response<any, Record<string, any>> | undefined>;
-export declare function findAllBuilder<FSchema extends ZodObject, TTable extends PgTable>(service: RetrieverService<FSchema, TTable>, filter: FSchema, hook?: (items: TTable["$inferSelect"][], total: number) => Response): (req: Request, res: Response) => Promise<Response<any, Record<string, any>>>;
-export declare function createBuilder<TTable extends PgTable, Schema extends ZodObject>(service: CreateService<TTable>, schema: Schema): (req: Request, res: Response) => Promise<Response<any, Record<string, any>>>;
-export declare function updateBuilder<TTable extends PgTable, Schema extends ZodObject>(service: UpdateService<TTable>, schema: Schema): (req: Request, res: Response) => Promise<Response<any, Record<string, any>>>;
-export declare function deleteBuilder<TTable extends PgTable>(service: DeleteService<TTable>): (req: Request, res: Response) => Promise<Response<any, Record<string, any>>>;
+import { Filter } from "./types";
+export declare function findOneBuilder<TReturn>(service: {
+    findOne: (id: any) => Promise<TReturn>;
+}, hook?: (item: TReturn) => void): (req: Request, res: Response) => Promise<void>;
+export declare function findAllBuilder<FSchema extends ZodObject, TReturn>(service: {
+    findAll: (filters?: Filter<FSchema>, page?: number, pageSize?: number) => Promise<TReturn[]>;
+    count: (filters?: Filter<FSchema>) => Promise<number>;
+}, filter: FSchema, hook?: (items: TReturn[], total: number) => void, hasPagination?: boolean): (req: Request, res: Response) => Promise<Response<any, Record<string, any>>>;
+export declare function createBuilder<CSchema extends ZodObject, TReturn>(service: {
+    create: (data: z.core.output<CSchema>) => Promise<TReturn>;
+}, schema: CSchema): (req: Request, res: Response) => Promise<Response<any, Record<string, any>>>;
+export declare function updateBuilder<USchema extends ZodObject, TReturn>(service: {
+    update: (id: any, data: z.core.output<USchema>) => Promise<TReturn>;
+}, schema: USchema): (req: Request, res: Response) => Promise<Response<any, Record<string, any>>>;
+export declare function deleteBuilder(service: {
+    delete: (id: any) => Promise<void>;
+}): (req: Request, res: Response) => Promise<Response<any, Record<string, any>>>;
 export declare function validate<T extends ZodObject>(schema: T, fn: (req: Request, res: Response, data: z.output<T>) => Promise<Response>): (req: Request, res: Response) => Promise<Response<any, Record<string, any>>>;
 interface CRUDService<FSchema extends ZodObject> {
     findOne: (id: any) => Promise<any>;
-    findAll: (filters?: Filter<FSchema>, page?: number, pageSize?: number) => Promise<any>;
+    findAll: (filters?: Filter<FSchema>, page?: number, pageSize?: number) => Promise<any[]>;
     count: (filters: Filter<FSchema>) => Promise<number>;
     create: (data: any) => Promise<any>;
     update: (id: any, data: Partial<any>) => Promise<any>;

package/dist/src/controller.js

@@ -11,34 +11,41 @@ function findOneBuilder(service, hook) {
     return async (req, res) => {
         const item = await service.findOne(req.params.id);
         if (hook !== undefined) {
-            return hook(item);
-        }
-        else {
-            res.status(200).json(item);
+            hook(item);
         }
+        res.status(200).json(item);
     };
 }
-function findAllBuilder(service, filter, hook) {
+function findAllBuilder(service, filter, hook, hasPagination = true) {
     return async (req, res) => {
         const filters = filter.parse({
             ...req.params,
             ...req.query
         });
-        const pagination = getPagination(req);
-        const [items, total] = await Promise.all([
-            service.findAll(filters, pagination.page, pagination.pageSize),
-            service.count(filters)
-        ]);
-        if (hook !== undefined) {
-            return hook(items, total);
+        let pagination, itemsProm;
+        if (hasPagination) {
+            pagination = getPagination(req);
+            itemsProm = service.findAll(filters, pagination.page, pagination.pageSize);
         }
         else {
+            itemsProm = service.findAll(filters);
+        }
+        const totalProm = service.count(filters);
+        const [items, total] = await Promise.all([itemsProm, totalProm]);
+        hook?.(items, total);
+        if (hasPagination) {
             return res.status(200).json({
                 pagination,
                 items,
                 total
             });
         }
+        else {
+            return res.status(200).json({
+                items,
+                total
+            });
+        }
     };
 }
 function createBuilder(service, schema) {

package/dist/src/standard.d.ts

@@ -10,7 +10,7 @@ export declare class ServiceBuilder<T extends Table, TSchema extends Record<stri
     readonly tableName: string;
     constructor(db: NodePgDatabase<TSchema>, table: T, map: FilterMap<FSchema>);
     findOne<S extends PgSelect>(select: S): (id: number) => Promise<Awaited<ReturnType<S["execute"]>>[number]>;
-    findAll<S extends PgSelect>(select: S): (filters?: Filter<FSchema>, page?: number, pageSize?: number) => Promise<Awaited<ReturnType<S["execute"]>>[number][]>;
+    findAll<S extends PgSelect>(select: S, paginated?: boolean): (filters?: Filter<FSchema>, page?: number, pageSize?: number) => Promise<Awaited<ReturnType<S["execute"]>>[number][]>;
     create(): (data: InferInsertModel<T>) => Promise<{ [Key in keyof T["_"]["columns"] & string as Key]: T["_"]["columns"][Key]["_"]["notNull"] extends true ? T["_"]["columns"][Key]["_"]["data"] : T["_"]["columns"][Key]["_"]["data"] | null; } extends infer T_1 ? { [K in keyof T_1]: T_1[K]; } : never>;
     update(): (id: PrimaryKeyType<T>, data: Partial<InferInsertModel<T>>) => Promise<{ [Key in keyof T["_"]["columns"] & string as Key]: T["_"]["columns"][Key]["_"]["notNull"] extends true ? T["_"]["columns"][Key]["_"]["data"] : T["_"]["columns"][Key]["_"]["data"] | null; } extends infer T_1 ? { [K in keyof T_1]: T_1[K]; } : never>;
     softDelete(): (id: PrimaryKeyType<T>) => Promise<void>;

package/dist/src/standard.js

@@ -19,14 +19,22 @@ class ServiceBuilder {
             return result[0];
         };
     }
-    findAll(select) {
-        return async (filters, page = 1, pageSize = 10) => {
-            const offset = (page - 1) * pageSize;
-            return await select
-                .where((0, drizzle_orm_1.and)((0, drizzle_orm_1.isNull)(this.table.deletedAt), (0, filters_1.buildFilters)(this.map, filters)))
-                .limit(pageSize)
-                .offset(offset);
-        };
+    findAll(select, paginated = true) {
+        const base = (f) => select
+            .where((0, drizzle_orm_1.and)((0, drizzle_orm_1.isNull)(this.table.deletedAt), (0, filters_1.buildFilters)(this.map, f)));
+        if (paginated) {
+            return async (filters, page = 1, pageSize = 10) => {
+                const offset = (page - 1) * pageSize;
+                return await base(filters)
+                    .limit(pageSize)
+                    .offset(offset);
+            };
+        }
+        else {
+            return async (filters) => {
+                return await base(filters);
+            };
+        }
     }
     create() {
         return async (data) => {

package/dist/src/types.d.ts

@@ -6,7 +6,7 @@ export interface RetrieverService<FSchema extends ZodObject, TTable extends PgTa
     count: (filters: Filter<FSchema>) => Promise<number>;
 }
 export interface FindOneService<TTable extends PgTable> {
-    findOne: (id: any) => Promise<TTable["$inferSelect"]>;
+    findOne: (id: any) => Promise<Partial<TTable>>;
 }
 export interface CreateService<TTable extends PgTable> {
     create: (data: TTable["$inferInsert"]) => Promise<TTable["$inferSelect"]>;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "bradb",
-    "version": "1.2.4",
+    "version": "1.3.0",
     "description": "",
     "main": "dist/index.js",
     "types": "dist/index.d.ts",