bradb 3.1.1 → 3.1.2

package/dist/src/builder.d.ts

@@ -1,3 +1,4 @@
+import { PgTable } from 'drizzle-orm/pg-core';
 import { BradConfig } from './config';
 export declare const nodeTypes: readonly ["validator", "controller", "service", "schema", "router", "filter", "db"];
 export type NodeType = typeof nodeTypes[number];
@@ -8,6 +9,8 @@ type Node = {
     adj: Node[];
     exports: string[];
 };
+type GeneratorFunc = (name: string, table: PgTable, imports: string[]) => string;
+export declare const generators: Record<NodeType, GeneratorFunc | null>;
 type Export = Record<string, any>;
 export declare const valid: Record<string, boolean>;
 export declare let mods: Export;

package/dist/src/builder.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.mods = exports.valid = exports.nodeTypes = void 0;
+exports.mods = exports.valid = exports.generators = exports.nodeTypes = void 0;
 exports.buildGraph = buildGraph;
 exports.addNodeTo = addNodeTo;
 exports.build = build;
@@ -24,6 +24,12 @@ const dependOn = {
     schema: [],
     db: []
 };
+/* CRUD Operations
+* # READ
+* router.getAll -> controller.getAll -> service.getAll -> schema
+*                  controller.count -> service.count -> schema
+* controller
+*/
 // Default and base exports for each node type
 const requiredExports = {
     validator: (name) => [`${name}Validator`],
@@ -34,7 +40,7 @@ const requiredExports = {
     filter: (name) => [`${name}FilterMap`],
     db: (name) => ["db"]
 };
-const generators = {
+exports.generators = {
     router: generators_1.generateRouter,
     controller: generators_1.generateController,
     validator: generators_1.generateValidator,
@@ -63,7 +69,7 @@ function buildGraph(cfg, name, type) {
         checked[id(n)] = true;
         try {
             // If config is set to override = true we not check the modules and re-write anywise
-            if (cfg.override) {
+            if (cfg.override && dependOn[type].length > 0) {
                 exports.valid[id(n)] = false;
             }
             else {
@@ -73,8 +79,6 @@ function buildGraph(cfg, name, type) {
             }
         }
         catch (err) {
-            console.error(err.message);
-            console.log(cfg.override);
             // it's not necessary to set it to false
             exports.valid[id(n)] = false;
         }
@@ -109,7 +113,7 @@ function build(root) {
         build(dep);
     }
     if (!exports.valid[id(root)]) {
-        const gen = generators[root.type];
+        const gen = exports.generators[root.type];
         if (!gen) {
             throw Error(`Missing generator for ${root.type}`);
         }
@@ -144,6 +148,10 @@ function checkNode(root) {
     console.log(`Checking ${root.name}.${root.type}...`);
     // throw the require error
     const module = require(root.path);
+    // const code = fs.readFileSync(root.path).toString();
+    //
+    // const a = addCrudOp(`${root.name}${requiredExports[root.type]}`, code, "getAll");
+    // console.log(a);
     for (const exp of root.exports) {
         if (!module[exp]) {
             throw new Error(`[Missing export]: Cannot import ${exp} from ${root.path}`);
@@ -151,6 +159,14 @@ function checkNode(root) {
     }
     return module;
 }
+function addCrudOp(name, code, op) {
+    const regex = new RegExp(`(export\s+const\s+${name}\s*=\s*\{)([\s\S]*?)\};`);
+    const match = code.match(regex);
+    if (!match) {
+        return code;
+    }
+    return match.toString();
+}
 function buildImportLine(from, to, maxColumns = 80) {
     const relativePath = buildRelativeImport(from.path, to.path);
     let sep = ' ';

package/dist/src/commands.js

@@ -4,6 +4,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const commander_1 = require("commander");
 const builder_1 = require("./builder");
 const config_1 = require("./config");
+const generators_1 = require("./generators");
 const program = new commander_1.Command();
 program.name("brad").description("BRAD - Generator");
 program
@@ -13,16 +14,19 @@ program
     .choices(builder_1.nodeTypes)
     .default("router"))
     .option('-o, --override', 'Generator will override the current code', false)
+    .option('--cb, --controller-with-builder', 'Generate controller using builder', false)
     .description("generate entity recursively")
     .action(async (name, type, options) => {
     const cfg = (0, config_1.loadConfig)();
     cfg.override = options.override || false;
+    if (options.controllerWithBuilder) {
+        builder_1.generators["controller"] = generators_1.generateControllerBuilder;
+    }
     require('ts-node/register');
     const root = (0, builder_1.buildGraph)(cfg, name, type);
     // Aca tendríamos que ir desde (name, type) hasta la raiz (name, "router")
     // y desde ahi, ver si tenemos dependencias de otra entidad
     console.log(JSON.stringify(root, null, 4));
-    console.log(builder_1.valid);
     (0, builder_1.build)(root);
 });
 program

package/dist/src/controller.d.ts

@@ -1,43 +1,20 @@
-import { PgTable } from "drizzle-orm/pg-core";
 import { Request, Response } from "express";
 import { z, ZodObject } from "zod";
 import { Filter } from "./types";
-import { InferInsertModel } from "drizzle-orm";
-export declare function findOneBuilder<TReturn>(service: {
-    findOne: (id: any) => Promise<TReturn>;
-}, hook?: (item: TReturn) => Promise<object>): (req: Request, res: Response) => Promise<Response<any, Record<string, any>> | undefined>;
-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) => Promise<object[]>, 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, hook?: (req: Request, res: Response, data: z.core.output<CSchema>, item: TReturn) => Promise<object>): (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 const paginationSchema: z.ZodObject<{
+    page: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+    pageSize: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+}, z.core.$strip>;
+export type Pagination = {
+    page: number;
+    pageSize: number;
+    total?: number;
+    count?: number;
+};
+export declare function newPagination(data: unknown): Pagination;
+export declare function findOneBuilder<PK extends ZodObject, Item>(findOne: (pk: z.output<PK>) => Promise<Item>, pkSchema: PK, hook?: (item: Item) => Promise<object>): (req: Request, res: Response) => Promise<Response<any, Record<string, any>> | undefined>;
+export declare function findAllBuilder<FSchema extends ZodObject, Item>(findAll: (filters?: Filter<FSchema>, p?: Pagination) => Promise<Item[]>, filter: FSchema, hook?: (items: Item[], total: number) => Promise<object[]>): (req: Request, res: Response) => Promise<Response<any, Record<string, any>>>;
+export declare function createBuilder<CSchema extends ZodObject, Item>(create: (data: z.core.output<CSchema>) => Promise<Item>, schema: CSchema, hook?: (req: Request, res: Response, data: z.core.output<CSchema>, item: Item) => Promise<object>): (req: Request, res: Response) => Promise<Response<any, Record<string, any>>>;
+export declare function updateBuilder<PKSchema extends ZodObject, USchema extends ZodObject, Item>(update: (pks: z.core.output<PKSchema>, data: z.core.output<USchema>) => Promise<Item>, pkSchema: PKSchema, schema: USchema): (req: Request, res: Response) => Promise<Response<any, Record<string, any>>>;
+export declare function deleteBuilder<PKSchema extends ZodObject>(remove: (id: z.core.output<PKSchema>) => Promise<void>, pkSchema: PKSchema): (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[]>;
-    count: (filters: Filter<FSchema>) => Promise<number>;
-    create: (data: any) => Promise<any>;
-    update: (id: any, data: Partial<any>) => Promise<any>;
-    delete: (id: any) => Promise<any>;
-}
-export declare class BaseController<T extends PgTable, FSchema extends z.ZodObject> {
-    protected service: CRUDService<FSchema>;
-    private filterSchema;
-    private createSchema;
-    private updateSchema;
-    constructor(service: CRUDService<FSchema>, base: z.ZodObject, filter: FSchema, createSchema?: z.ZodSchema<InferInsertModel<T>>, updateSchema?: Partial<InferInsertModel<T>>);
-    getAll: (req: Request, res: Response) => Promise<void>;
-    getById: (req: Request, res: Response) => Promise<void>;
-    create: (req: Request, res: Response) => Promise<void>;
-    update: (req: Request, res: Response) => Promise<void>;
-    delete: (req: Request, res: Response) => Promise<void>;
-}
-export {};

package/dist/src/controller.js

@@ -1,15 +1,26 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.BaseController = void 0;
+exports.paginationSchema = void 0;
+exports.newPagination = newPagination;
 exports.findOneBuilder = findOneBuilder;
 exports.findAllBuilder = findAllBuilder;
 exports.createBuilder = createBuilder;
 exports.updateBuilder = updateBuilder;
 exports.deleteBuilder = deleteBuilder;
 exports.validate = validate;
-function findOneBuilder(service, hook) {
+const zod_1 = require("zod");
+exports.paginationSchema = zod_1.z.object({
+    page: zod_1.z.coerce.number().default(1),
+    pageSize: zod_1.z.coerce.number().default(10)
+});
+function newPagination(data) {
+    const p = exports.paginationSchema.parse(data);
+    return p;
+}
+function findOneBuilder(findOne, pkSchema, hook) {
     return async (req, res) => {
-        const item = await service.findOne(req.params.id);
+        const pk = pkSchema.parse(req.params);
+        const item = await findOne(pk);
         if (hook !== undefined) {
             const i = await hook(item);
             return res.status(200).json(i);
@@ -17,44 +28,33 @@ function findOneBuilder(service, hook) {
         res.status(200).json(item);
     };
 }
-function findAllBuilder(service, filter, hook, hasPagination = true) {
+function findAllBuilder(findAll, filter, hook) {
     return async (req, res) => {
         const filters = filter.parse({
             ...req.params,
             ...req.query
         });
-        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]);
+        const pagination = newPagination(req.query);
+        const items = await findAll(filters, pagination);
         let resItems = items;
         if (hook != undefined) {
-            resItems = await hook(items, total);
-        }
-        if (hasPagination) {
-            return res.status(200).json({
-                pagination,
-                items: resItems,
-                total
-            });
-        }
-        else {
-            return res.status(200).json({
-                items: resItems,
-                total
-            });
+            if (!pagination.total) {
+                resItems = await hook(items, items.length);
+            }
+            else {
+                resItems = await hook(items, pagination.total);
+            }
         }
+        return res.status(200).json({
+            pagination,
+            items: resItems,
+            total: pagination.total
+        });
     };
 }
-function createBuilder(service, schema, hook) {
+function createBuilder(create, schema, hook) {
     return validate(schema, async (req, res, data) => {
-        const item = await service.create(data);
+        const item = await create(data);
         if (hook) {
             const i = await hook(req, res, data, item);
             return res.status(201).json(i);
@@ -62,15 +62,17 @@ function createBuilder(service, schema, hook) {
         return res.status(201).json(item);
     });
 }
-function updateBuilder(service, schema) {
+function updateBuilder(update, pkSchema, schema) {
     return validate(schema, async (req, res, data) => {
-        const item = await service.update(req.params.id, data);
+        const pk = pkSchema.parse(req.params);
+        const item = await update(pk, data);
         return res.status(200).json(item);
     });
 }
-function deleteBuilder(service) {
+function deleteBuilder(remove, pkSchema) {
     return async (req, res) => {
-        await service.delete(req.params.id);
+        const pk = pkSchema.parse(req.params);
+        await remove(pk);
         return res.status(204).send();
     };
 }
@@ -80,65 +82,3 @@ function validate(schema, fn) {
         return fn(req, res, validated);
     };
 }
-function getPagination(req) {
-    return {
-        page: req.query.page ? parseInt(req.query.page) : 1,
-        pageSize: req.query.pageSize
-            ? parseInt(req.query.pageSize)
-            : 10
-    };
-}
-class BaseController {
-    constructor(service, base, filter, createSchema, updateSchema) {
-        this.getAll = async (req, res) => {
-            const filters = getFilters(req, this.filterSchema);
-            const pagination = getPagination(req);
-            const [items, total] = await Promise.all([
-                this.service.findAll(filters, pagination.page, pagination.pageSize),
-                this.service.count(filters)
-            ]);
-            res.status(200).json({
-                pagination,
-                items,
-                total
-            });
-        };
-        this.getById = async (req, res) => {
-            const item = await this.service.findOne(req.params.id);
-            res.status(200).json(item);
-        };
-        this.create = async (req, res) => {
-            const data = this.createSchema.parse(req.body);
-            const item = await this.service.create(data);
-            res.status(201).json(item);
-        };
-        this.update = async (req, res) => {
-            const data = this.updateSchema.parse(req.body);
-            const item = await this.service.update(req.params.id, data);
-            res.status(200).json(item);
-        };
-        this.delete = async (req, res) => {
-            await this.service.delete(req.params.id);
-            res.status(204).send();
-        };
-        this.service = service;
-        // @ts-expect-error infer schema
-        this.createSchema = createSchema || base.omit({
-            id: true,
-            deletedAt: true
-        });
-        // @ts-expect-error infer schema
-        this.updateSchema = updateSchema || base.partial();
-        this.filterSchema = filter;
-    }
-}
-exports.BaseController = BaseController;
-/*
-    * Extract the filters from the Request
-*/
-function getFilters(req, filter) {
-    return filter.parse({
-        ...req.params,
-        ...req.query
-    });
-}

package/dist/src/errors.js

@@ -2,7 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.errorHandler = exports.Unauthorized = exports.Forbidden = exports.BadRequest = exports.Duplicated = exports.NotFound = exports.ServiceError = void 0;
 exports.handleSqlError = handleSqlError;
-const drizzle_orm_1 = require("drizzle-orm");
 const zod_1 = require("zod");
 class ServiceError extends Error {
     constructor(statusCode, message) {
@@ -45,10 +44,16 @@ class Unauthorized extends ServiceError {
 exports.Unauthorized = Unauthorized;
 const errorHandler = (err, req, res, next) => {
     if (err instanceof ServiceError) {
-        return res.status(err.statusCode).json({ message: err.message });
+        return res.status(err.statusCode).json({
+            success: false,
+            code: err.statusCode,
+            message: err.message
+        });
     }
     if (err instanceof zod_1.ZodError) {
         return res.status(400).json({
+            success: false,
+            code: 400,
             message: "Validation failed",
             errors: err.issues
         });
@@ -61,7 +66,7 @@ exports.errorHandler = errorHandler;
 // infiera bien los tipos
 function handleSqlError(e) {
     let err = e;
-    if (e instanceof drizzle_orm_1.DrizzleQueryError && e.cause) {
+    if (instanceOf(e) && e.cause) {
         const cause = e.cause;
         if (/duplicate key/i.test(cause.message)) {
             if (isPgErrorWithDetail(cause)) {
@@ -82,6 +87,14 @@ function handleSqlError(e) {
     }
     throw err;
 }
+// Safer version of instanceof that works on vitest too
+function instanceOf(err) {
+    return typeof err === 'object' &&
+        err !== null &&
+        'constructor' in err &&
+        'name' in err.constructor &&
+        err.constructor.name === "DrizzleQueryError";
+}
 function isPgErrorWithDetail(err) {
     return (typeof err === "object" &&
         err !== null &&

package/dist/src/filters.d.ts

@@ -5,5 +5,8 @@ import { AnyPgTable, PgColumn } from "drizzle-orm/pg-core";
 export declare const createFilterSchema: import("drizzle-zod").CreateInsertSchema<{
     number: true;
 }>;
+export declare const createPkSchema: import("drizzle-zod").CreateSelectSchema<{
+    number: true;
+}>;
 export declare function buildFilters<FSchema extends ZodObject>(map: FilterMap<FSchema>, filters?: Filter<FSchema>): SQL<unknown> | undefined;
 export declare function buildPKFilters<T extends AnyPgTable>(pks: PgColumn[], values: PrimaryKeyData<T>): SQL<unknown> | undefined;

package/dist/src/filters.js

@@ -1,16 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createFilterSchema = void 0;
+exports.createPkSchema = exports.createFilterSchema = void 0;
 exports.buildFilters = buildFilters;
 exports.buildPKFilters = buildPKFilters;
 const drizzle_orm_1 = require("drizzle-orm");
 const drizzle_zod_1 = require("drizzle-zod");
-const { createInsertSchema } = (0, drizzle_zod_1.createSchemaFactory)({
+const { createInsertSchema, createSelectSchema } = (0, drizzle_zod_1.createSchemaFactory)({
     coerce: {
         number: true,
     },
 });
 exports.createFilterSchema = createInsertSchema;
+exports.createPkSchema = createSelectSchema;
 function buildFilters(map, filters) {
     const conditions = [];
     if (!filters)

package/dist/src/generators.d.ts

@@ -2,6 +2,7 @@ import { PgTable } from "drizzle-orm/pg-core";
 export declare function generateRouter(name: string, table: PgTable, imports: string[]): string;
 export declare function generateValidator(name: string, table: PgTable, imports: string[]): string;
 export declare function generateController(name: string, table: PgTable, imports: string[]): string;
+export declare function generateControllerBuilder(name: string, table: PgTable, imports: string[]): string;
 export declare function generateService(name: string, table: PgTable, imports: string[]): string;
 export declare function generateFilter(name: string, table: PgTable, imports: string[]): string;
 export declare function getRelationName(fkName: string): string;

package/dist/src/generators.js

@@ -3,14 +3,21 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateRouter = generateRouter;
 exports.generateValidator = generateValidator;
 exports.generateController = generateController;
+exports.generateControllerBuilder = generateControllerBuilder;
 exports.generateService = generateService;
 exports.generateFilter = generateFilter;
 exports.getRelationName = getRelationName;
-const pg_core_1 = require("drizzle-orm/pg-core");
 const pg_1 = require("./pg");
+const drizzle_orm_1 = require("drizzle-orm");
 function generateRouter(name, table, imports) {
     const pkColumns = (0, pg_1.getPKs)(table);
-    const route = pkColumns.map(pk => `${getRelationName(pk.name)}/:${pk.name}`).join("/");
+    let route = '';
+    if (pkColumns.length == 1) {
+        route = `:${pkColumns[0].name}`;
+    }
+    else {
+        route = pkColumns.map(pk => `${getRelationName(pk.name)}/:${pk.name}`).join("/");
+    }
     return `import { Router } from "express";
 ${imports.join('\n')};
 export const ${name}Router = Router();
@@ -22,19 +29,19 @@ ${name}Router.get("/", ${name}Controller.getAll);
 ${name}Router.post("/", ${name}Controller.create);
 
 // Get one
-${name}Router.get("${route}", ${name}Controller.getOne);
+${name}Router.get("/${route}", ${name}Controller.getOne);
 
 // Update
-${name}Router.put("${route}", ${name}Controller.update);
+${name}Router.put("/${route}", ${name}Controller.update);
 
 // Delete
-${name}Router.delete("${route}", ${name}Controller.remove);`;
+${name}Router.delete("/${route}", ${name}Controller.remove);`;
 }
 function generateValidator(name, table, imports) {
     const pkColumns = (0, pg_1.getPKs)(table);
     const zodPkPicker = buildZodPkPicker(pkColumns);
     return `import { createInsertSchema, createSelectSchema } from "drizzle-zod";
-import { createFilterSchema } from "bradb";
+import { createFilterSchema, createPkSchema } from "bradb";
 import { z } from "zod";
 ${imports.join('\n')};
 
@@ -42,7 +49,7 @@ const select = createSelectSchema(${name}Table);
 const insert = createInsertSchema(${name}Table);
 const update = insert.partial();
 const filter = createFilterSchema(${name}Table).partial();
-const pk = select.pick({
+const pk = createPkSchema(${name}Table).pick({
     ${zodPkPicker}
 });
 
@@ -62,16 +69,18 @@ export const ${name}Validator = {
 }
 function generateController(name, table, imports) {
     return `import { Request, Response } from "express";
+import { newPagination } from "bradb";
 ${imports.join('\n')};
 
 async function getAll(req: Request, res: Response) {
+    const pagination = newPagination(req.query);
     const filters = ${name}Validator.filter.parse(req.query);
-    const items = await ${name}Service.findAll(filters);
-    const total = await ${name}Service.count(filters);
+    const items = await ${name}Service.findAll(filters, pagination);
 
     res.json({
+        pagination,
         items,
-        total
+        total: pagination.total // this is going to be removed
     });
 }
 
@@ -108,29 +117,52 @@ export const ${name}Controller = {
     remove
 };`;
 }
+function generateControllerBuilder(name, table, imports) {
+    return `import {
+    findAllBuilder,
+    findOneBuilder,
+    updateBuilder,
+    deleteBuilder,
+    createBuilder
+} from "bradb";
+${imports.join('\n')};
+
+export const ${name}Controller = {
+    getAll: findAllBuilder(${name}Service.findAll, ${name}Validator.filter),
+    getOne: findOneBuilder(${name}Service.findOne, ${name}Validator.pk),
+    create: createBuilder(${name}Service.create, ${name}Validator.insert),
+    update: updateBuilder(${name}Service.update, ${name}Validator.pk, ${name}Validator.update),
+    remove: deleteBuilder(${name}Service.delete, ${name}Validator.pk)
+};`;
+}
 function generateService(name, table, imports) {
+    const selection = `db
+            .select()
+            .from(${name}Table)
+            .$dynamic()`;
     return `import { ServiceBuilder } from "bradb";
 ${imports.join('\n')};
 
 const builder = new ServiceBuilder(db, ${name}Table, ${name}FilterMap);
 
-const selection = db
-    .select()
-    .from(${name}Table)
-    .$dynamic();
-
 export const ${name}Service = {
     create: builder.create(),
     update: builder.update(),
-    count: builder.count(),
     delete: builder.delete(),
-    findAll: builder.findAll(selection),
-    findOne: builder.findOne(selection)
+    findAll: builder.findAll(
+        ${selection}
+    ),
+    findOne: builder.findOne(
+        ${selection}
+    )
 };`;
 }
 function generateFilter(name, table, imports) {
-    const { columns } = (0, pg_core_1.getTableConfig)(table);
-    const filters = columns.map(c => `${c.name}: (val) => eq(${name}Table.${c.name}, val)`).join(',\n\t');
+    // const { columns } = getTableConfig(table);
+    const columns = (0, drizzle_orm_1.getTableColumns)(table);
+    const filters = Object.entries(columns).map(([colName, _]) => {
+        return `${colName}: (val) => eq(${name}Table.${colName}, val)`;
+    }).join(',\n\t');
     return `import { FilterMap } from "bradb";
 import { eq } from "drizzle-orm";
 ${imports.join('\n')};

package/dist/src/service.d.ts

@@ -1,8 +1,9 @@
 import { Filter, FilterMap, PrimaryKeyData } from "./types";
-import { AnyPgTable, PgColumn, PgSelect, PgTransaction } from "drizzle-orm/pg-core";
+import { AnyPgColumn, AnyPgTable, PgColumn, PgSelect, PgTransaction, SelectedFields } from "drizzle-orm/pg-core";
 import { NodePgDatabase } from "drizzle-orm/node-postgres";
 import { InferInsertModel, SQL } from "drizzle-orm";
 import { ZodObject } from "zod";
+import { Pagination } from "./controller";
 export declare class ServiceBuilder<T extends AnyPgTable, TSchema extends Record<string, unknown>, FSchema extends ZodObject, PKType extends object = PrimaryKeyData<T>> {
     private readonly db;
     private readonly table;
@@ -13,12 +14,17 @@ export declare class ServiceBuilder<T extends AnyPgTable, TSchema extends Record
     readonly findOneConditions: (pkFilter: PKType) => SQL | undefined;
     readonly tableName: string;
     constructor(db: NodePgDatabase<TSchema>, table: T, map: FilterMap<FSchema>);
-    findOne<S extends PgSelect>(select: S): (pkValues: PKType) => 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][]>;
-    count(): (filters?: Filter<FSchema>) => Promise<number>;
+    findOne<S extends PgSelect>(select: S): (pkValues: PKType) => Promise<S["_"]["result"][0]>;
+    TEST<F extends SelectedFields>(fields: F, cb: (qb: PgSelect) => PgSelect): (pkValues: PKType) => Promise<RowFromFields<F>>;
+    findAll<S extends PgSelect>(select: S, paginated?: boolean): (filters?: Filter<FSchema>, p?: Pagination) => Promise<S["_"]["result"][0][]>;
+    count<S extends PgSelect>(select?: S): (filters?: Filter<FSchema>) => Promise<number>;
     create<S extends any>(hook?: (data: S extends Object ? S : InferInsertModel<T>, tx?: PgTransaction<any, TSchema, any>) => Promise<InferInsertModel<T>>): (data: S extends Object ? S : InferInsertModel<T>, tx?: PgTransaction<any, TSchema, any>) => 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<S extends any>(pre?: (data: S extends Object ? S : Partial<InferInsertModel<T>>, tx?: PgTransaction<any, TSchema, any>) => Promise<InferInsertModel<T>>): (pks: PKType, data: S extends Object ? S : Partial<InferInsertModel<T>>, tx?: PgTransaction<any, TSchema, any>) => 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>;
     delete(): (pks: PKType, tx?: PgTransaction<any, TSchema, any>) => Promise<void>;
     softDelete(): (pks: PKType, tx?: PgTransaction<any, TSchema, any>) => Promise<void>;
     hardDelete(): (pks: PKType, tx?: PgTransaction<any, TSchema, any>) => Promise<void>;
 }
+type RowFromFields<T extends SelectedFields> = {
+    [K in keyof T]: T[K] extends AnyPgColumn ? T[K]['_']['data'] : never;
+};
+export {};

package/dist/src/service.js

@@ -31,23 +31,52 @@ class ServiceBuilder {
             return result[0];
         };
     }
+    TEST(fields, cb) {
+        return async (pkValues) => {
+            const pre = this.db.select(fields).from(this.table).$dynamic();
+            const result = await cb(pre).where(this.findOneConditions(pkValues));
+            if (result.length == 0)
+                throw notFoundWithId(this.tableName, pkValues);
+            return result[0];
+        };
+    }
     findAll(select, paginated = true) {
         const base = (f) => select.where(this.findAllConditions(f));
         if (paginated) {
-            return async (filters, page = 1, pageSize = 10) => {
-                const offset = (page - 1) * pageSize;
-                return await base(filters)
-                    .limit(pageSize)
-                    .offset(offset);
+            return async (filters, p) => {
+                if (!p)
+                    p = {
+                        page: 1,
+                        pageSize: 10
+                    };
+                const countQuery = this.db
+                    .select({ count: (0, drizzle_orm_1.count)() })
+                    .from(this.table)
+                    .where(this.findAllConditions(filters));
+                const offset = (p.page - 1) * p.pageSize;
+                const items = await base(filters).limit(p.pageSize).offset(offset);
+                const [res] = await countQuery;
+                p.total = res.count;
+                p.count = items.length;
+                return items;
             };
         }
         else {
             return async (filters) => {
-                return await base(filters);
+                const items = await base(filters);
+                return items;
             };
         }
     }
-    count() {
+    count(select) {
+        if (select) {
+            return async (filters) => {
+                const base = select.where(this.findAllConditions(filters));
+                const subquery = base.as('countsubquery');
+                const [result] = await this.db.select({ count: (0, drizzle_orm_1.count)() }).from(subquery);
+                return result.count;
+            };
+        }
         return async (filters) => {
             const [result] = await this.db
                 .select({ count: (0, drizzle_orm_1.count)() })

package/dist/src/types.d.ts

@@ -1,22 +1,12 @@
 import { SQL } from "drizzle-orm";
-import { AnyPgTable, PgColumn, PgTable, PgTransaction } from "drizzle-orm/pg-core";
+import { AnyPgTable, PgTable, PgTransaction } from "drizzle-orm/pg-core";
 import z, { ZodObject } from "zod";
-export interface RetrieverService<FSchema extends ZodObject, TTable extends PgTable> {
-    findAll: (filters?: Filter<FSchema>, page?: number, pageSize?: number) => Promise<TTable["$inferSelect"][]>;
-    count: (filters: Filter<FSchema>) => Promise<number>;
-}
-export interface FindOneService<TTable extends PgTable> {
-    findOne: (id: PrimaryKeyType<TTable>) => Promise<Partial<TTable>>;
-}
-export interface CreateService<TTable extends PgTable, TSchema extends Record<string, unknown>> {
-    create: (data: TTable["$inferInsert"], tx?: PgTransaction<any, TSchema, any>) => Promise<TTable["$inferSelect"]>;
-}
-export interface UpdateService<TTable extends PgTable, TSchema extends Record<string, unknown>> {
-    update: (id: PrimaryKeyType<TTable>, data: Partial<TTable["$inferInsert"]>, tx?: PgTransaction<any, TSchema, any>) => Promise<TTable["$inferSelect"]>;
-}
-export interface DeleteService<TTable extends PgTable, TSchema extends Record<string, unknown>> {
-    delete: (id: PrimaryKeyType<TTable>, tx?: PgTransaction<any, TSchema, any>) => Promise<void>;
-}
+export type FindOneFunc<T extends PgTable> = (pks: PrimaryKeyData<T>) => Promise<object>;
+export type FindAllFunc<F extends ZodObject> = (filters?: F, page?: number, pageSize?: number) => Promise<object>;
+export type CountFunc<F extends ZodObject> = (filters?: F) => Promise<object>;
+export type CreateFunc<T extends PgTable> = (data: T["$inferInsert"], tx?: PgTransaction<any, any, any>) => Promise<T["$inferSelect"]>;
+export type UpdateFunc<T extends PgTable> = (pks: PrimaryKeyData<T>, data: Partial<T["$inferInsert"]>, tx?: PgTransaction<any, any, any>) => Promise<T["$inferSelect"]>;
+export type DeleteFunc<T extends PgTable> = (pks: PrimaryKeyData<T>) => Promise<void>;
 export type PrimaryKeyData<TTable extends AnyPgTable> = {
     [K in keyof TTable["_"]["columns"] as TTable["_"]["columns"][K] extends {
         _: {
@@ -24,15 +14,6 @@ export type PrimaryKeyData<TTable extends AnyPgTable> = {
         };
     } ? K : never]: TTable["_"]["columns"][K]["_"]["data"];
 };
-export interface PaginationParams {
-    page: number;
-    pageSize: number;
-}
-export type Table = AnyPgTable & {
-    deletedAt: PgColumn;
-    id: any;
-};
-export type PrimaryKeyType<T extends AnyPgTable> = T["_"]["columns"]["id"]["_"]["data"];
 export type FilterMap<Schema extends z.ZodObject, Out = z.infer<Schema>> = {
     [K in keyof Out]: (value: NonNullable<Out[K]>) => SQL;
 };

package/package.json

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