bradb 1.2.3 → 1.3.0

package/dist/src/controller.d.ts

@@ -1,7 +1,32 @@
 import { PgTable } from "drizzle-orm/pg-core";
 import { Request, Response } from "express";
-import { z } from "zod";
-import { CRUDService } from "./types";
+import { z, ZodObject } from "zod";
+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[]>;
+    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;
@@ -14,3 +39,4 @@ export declare class BaseController<T extends PgTable, FSchema extends z.ZodObje
     update: (req: Request, res: Response) => Promise<void>;
     delete: (req: Request, res: Response) => Promise<void>;
 }
+export {};

package/dist/src/controller.js

@@ -1,6 +1,85 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BaseController = void 0;
+exports.findOneBuilder = findOneBuilder;
+exports.findAllBuilder = findAllBuilder;
+exports.createBuilder = createBuilder;
+exports.updateBuilder = updateBuilder;
+exports.deleteBuilder = deleteBuilder;
+exports.validate = validate;
+function findOneBuilder(service, hook) {
+    return async (req, res) => {
+        const item = await service.findOne(req.params.id);
+        if (hook !== undefined) {
+            hook(item);
+        }
+        res.status(200).json(item);
+    };
+}
+function findAllBuilder(service, filter, hook, hasPagination = true) {
+    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]);
+        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) {
+    return validate(schema, async (req, res, data) => {
+        const item = await service.create(data);
+        return res.status(201).json(item);
+    });
+}
+function updateBuilder(service, schema) {
+    return validate(schema, async (req, res, data) => {
+        const item = await service.update(req.params.id, data);
+        return res.status(200).json(item);
+    });
+}
+function deleteBuilder(service) {
+    return async (req, res) => {
+        await service.delete(req.params.id);
+        return res.status(204).send();
+    };
+}
+function validate(schema, fn) {
+    return async (req, res) => {
+        const validated = schema.parse(req.body);
+        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) {
         this.getAll = async (req, res) => {
@@ -55,14 +134,3 @@ function getFilters(req, filter) {
         ...req.query
     });
 }
-/*
-    * Extract PaginationParams from the request
-*/
-function getPagination(req) {
-    return {
-        page: req.query.page ? parseInt(req.query.page) : 1,
-        pageSize: req.query.pageSize
-            ? parseInt(req.query.pageSize)
-            : 10
-    };
-}

package/dist/src/relational.d.ts

@@ -1,8 +1,8 @@
 import { Filter, FilterMap } from "../src/types";
-import { BuildQueryResult, DBQueryConfig, TableRelationalConfig, TablesRelationalConfig } from "drizzle-orm";
+import { BuildQueryResult, DBQueryConfig, KnownKeysOnly, TableRelationalConfig, TablesRelationalConfig } from "drizzle-orm";
 import { RelationalQueryBuilder } from "drizzle-orm/pg-core/query-builders/query";
 import { ZodObject } from "zod";
 export declare function RelationalBuilder<TSchema extends TablesRelationalConfig, TFields extends TableRelationalConfig, FSchema extends ZodObject>(q: RelationalQueryBuilder<TSchema, TFields>, filterMap: FilterMap<FSchema>): {
     findAll<TConfig extends DBQueryConfig<"many", true, TSchema, TFields>>(config?: TConfig): (filters?: Filter<FSchema>, page?: number, pageSize?: number) => Promise<BuildQueryResult<TSchema, TFields, TConfig>[]>;
-    findOne<TSelection extends Omit<DBQueryConfig<"many", true, TSchema, TFields>, "limit">>(config?: DBQueryConfig<any, true, TSchema, TFields>): (id: number) => Promise<BuildQueryResult<TSchema, TFields, TSelection>>;
+    findOne<TSelection extends Omit<DBQueryConfig<"many", true, TSchema, TFields>, "limit">>(config?: KnownKeysOnly<TSelection, Omit<DBQueryConfig<"many", true, TSchema, TFields>, "limit">>): (id: number) => Promise<BuildQueryResult<TSchema, TFields, TSelection>>;
 };

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<S>;
+    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

@@ -1,13 +1,21 @@
 import { SQL } from "drizzle-orm";
-import { AnyPgTable, PgColumn } from "drizzle-orm/pg-core";
+import { AnyPgTable, PgColumn, PgTable } from "drizzle-orm/pg-core";
 import z, { ZodObject } from "zod";
-export interface CRUDService<FSchema extends ZodObject> {
-    findOne: (id: any) => Promise<any>;
-    findAll: (filters?: Filter<FSchema>, page?: number, pageSize?: number) => Promise<any>;
+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>;
-    create: (data: any) => Promise<any>;
-    update: (id: any, data: Partial<any>) => Promise<any>;
-    delete: (id: any) => Promise<any>;
+}
+export interface FindOneService<TTable extends PgTable> {
+    findOne: (id: any) => Promise<Partial<TTable>>;
+}
+export interface CreateService<TTable extends PgTable> {
+    create: (data: TTable["$inferInsert"]) => Promise<TTable["$inferSelect"]>;
+}
+export interface UpdateService<TTable extends PgTable> {
+    update: (id: any, data: Partial<TTable["$inferInsert"]>) => Promise<TTable["$inferSelect"]>;
+}
+export interface DeleteService<TTable extends PgTable> {
+    delete: (id: any) => Promise<TTable["$inferSelect"]>;
 }
 export type PrimaryKeyData<TTable extends AnyPgTable> = {
     [K in keyof TTable["_"]["columns"] as TTable["_"]["columns"][K] extends {

package/package.json

@@ -1,12 +1,11 @@
 {
     "name": "bradb",
-    "version": "1.2.3",
+    "version": "1.3.0",
     "description": "",
     "main": "dist/index.js",
     "types": "dist/index.d.ts",
     "files": [
-        "dist",
-        "index.d.ts"
+        "dist"
     ],
     "scripts": {
         "build": "rm -rf dist/ && tsc",