bradb 1.2.4 → 2.0.0

package/dist/bin/brad.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/bin/brad.js

@@ -0,0 +1,52 @@
+#!/usr/bin/env node
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const commands_1 = __importDefault(require("../src/commands"));
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const args = process.argv.slice(2);
+const main = async () => {
+    // Load config file
+    const configPath = path_1.default.resolve(process.cwd(), 'brad.config.mjs');
+    let config = {};
+    if (fs_1.default.existsSync(configPath)) {
+        try {
+            const loadedConfig = require(configPath);
+            config = loadedConfig.default || loadedConfig;
+            console.log(config);
+            console.log("Loaded brad.config.js");
+        }
+        catch (e) {
+            console.error("Error loading brad.config.js:", e);
+            return;
+        }
+    }
+    else {
+        console.warn("Warning: brad.config.js not found. Using default settings.");
+    }
+    if (args.length === 0) {
+        console.log("Brad CLI - Available commands: make:entity");
+        return;
+    }
+    const command = args[0];
+    if (command === 'make:entity') {
+        const entityName = args[1];
+        if (!entityName) {
+            console.error("Error: Entity name is required. Usage: brad make:entity <EntityName>");
+            return;
+        }
+        let basePath = 'src'; // Default path
+        const pathArg = args.find(arg => arg.startsWith('--path='));
+        if (pathArg) {
+            basePath = pathArg.split('=')[1];
+        }
+        await commands_1.default.createEntity(entityName, basePath, config);
+    }
+    else {
+        console.error(`Error: Unknown command '${command}'`);
+    }
+};
+main();

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 export * from './src/types';
 export * from './src/controller';
-export * from './src/standard';
+export * from './src/service';
 export * from './src/relational';
 export * from './src/filters';
 export * from './src/errors';

package/dist/index.js

@@ -16,7 +16,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./src/types"), exports);
 __exportStar(require("./src/controller"), exports);
-__exportStar(require("./src/standard"), exports);
+__exportStar(require("./src/service"), exports);
 __exportStar(require("./src/relational"), exports);
 __exportStar(require("./src/filters"), exports);
 __exportStar(require("./src/errors"), exports);

package/dist/src/commands.d.ts

@@ -0,0 +1,20 @@
+type BradConfig = {
+    dbConnection?: string;
+    schemas?: string;
+    routesDir?: string;
+    controllerDir?: string;
+    serviceDir?: string;
+};
+declare class Commander {
+    config: Required<Omit<BradConfig, 'dbConnection' | 'schemas'>>;
+    constructor(config?: BradConfig);
+    private capitalize;
+    private toCamelCase;
+    private formatImportPath;
+    createEntity(entityName: string, basePath?: string, config?: BradConfig): Promise<void>;
+    private createServiceFile;
+    private createControllerFile;
+    private createRouterFile;
+}
+declare const _default: Commander;
+export default _default;

package/dist/src/commands.js

@@ -0,0 +1,116 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = require("fs");
+const path_1 = __importDefault(require("path"));
+const defaultConfig = {
+    routesDir: "routers",
+    controllerDir: "controllers",
+    serviceDir: "services"
+};
+class Commander {
+    constructor(config = {}) {
+        this.config = { ...defaultConfig, ...config };
+    }
+    capitalize(str) {
+        return str.charAt(0).toUpperCase() + str.slice(1);
+    }
+    toCamelCase(str) {
+        return str.charAt(0).toLowerCase() + str.slice(1);
+    }
+    formatImportPath(importPath) {
+        const parsed = path_1.default.parse(importPath);
+        return path_1.default.join(parsed.dir, parsed.name).replace(/\\/g, '/');
+    }
+    async createEntity(entityName, basePath = 'src', config = {}) {
+        const capitalizedName = this.capitalize(entityName);
+        const camelCaseName = this.toCamelCase(entityName);
+        const controllerDir = path_1.default.resolve(basePath, this.config.controllerDir);
+        const serviceDir = path_1.default.resolve(basePath, this.config.serviceDir);
+        const routerDir = path_1.default.resolve(basePath, this.config.routesDir);
+        try {
+            await fs_1.promises.mkdir(controllerDir, { recursive: true });
+            await fs_1.promises.mkdir(serviceDir, { recursive: true });
+            await fs_1.promises.mkdir(routerDir, { recursive: true });
+            await this.createServiceFile(serviceDir, entityName, camelCaseName, config);
+            await this.createControllerFile(controllerDir, entityName, camelCaseName);
+            await this.createRouterFile(routerDir, entityName, camelCaseName);
+            console.log(`Entity ${entityName} created successfully!`);
+            console.log(`- ${path_1.default.join(serviceDir, `${entityName}.service.ts`)}`);
+            console.log(`- ${path_1.default.join(controllerDir, `${entityName}.controller.ts`)}`);
+            console.log(`- ${path_1.default.join(routerDir, `${entityName}.router.ts`)}`);
+        }
+        catch (error) {
+            console.error("Error creating entity:", error);
+        }
+    }
+    async createServiceFile(dir, name, camelCaseName, config) {
+        let dbImport = `import { db } from '../db'; // fallback`;
+        let schemaImport = `import { ${camelCaseName}Table } from '../schema'; // fallback`;
+        if (config.dbConnection) {
+            const dbPath = path_1.default.relative(dir, path_1.default.resolve(config.dbConnection));
+            dbImport = `import { db } from '${this.formatImportPath(dbPath)}';`;
+        }
+        if (config.schemas) {
+            const schemaPath = path_1.default.relative(dir, path_1.default.resolve(config.schemas));
+            schemaImport = `import { ${camelCaseName}Table } from '${this.formatImportPath(schemaPath)}';`;
+        }
+        const serviceTemplate = `import { ServiceBuilder } from 'bradb';
+${dbImport}
+${schemaImport}
+
+// TODO: Define your filter map
+// import { ${camelCaseName}FilterMap } from '../filter';
+
+const builder = new ServiceBuilder(db, ${camelCaseName}Table, {});
+
+export const ${camelCaseName}Service = {
+    create: builder.create(),
+    update: builder.update(),
+    delete: builder.softDelete(),
+    findOne: builder.findOne(
+        db.select().from(${camelCaseName}Table).$dynamic()
+    ),
+    findAll: builder.findAll(
+        db.select().from(${camelCaseName}Table).$dynamic()
+    ),
+    count: builder.count()
+};
+`;
+        await fs_1.promises.writeFile(path_1.default.join(dir, `${name}.service.ts`), serviceTemplate);
+    }
+    async createControllerFile(dir, name, camelCaseName) {
+        const controllerTemplate = `import { createBuilder, findAllBuilder, findOneBuilder, updateBuilder, deleteBuilder } from 'bradb';
+import { ${camelCaseName}Service } from '../services/${name}.service';
+// import { ${camelCaseName}CreateSchema, ${camelCaseName}UpdateSchema } from '../validators'; // Adjust this import
+
+export const ${camelCaseName}Controller = {
+    create: createBuilder(${camelCaseName}Service), // Add schema validator as second argument
+    findAll: findAllBuilder(${camelCaseName}Service),
+    findOne: findOneBuilder(${camelCaseName}Service),
+    update: updateBuilder(${camelCaseName}Service), // Add schema validator as second argument
+    delete: deleteBuilder(${camelCaseName}Service)
+};
+`;
+        await fs_1.promises.writeFile(path_1.default.join(dir, `${name}.controller.ts`), controllerTemplate);
+    }
+    async createRouterFile(dir, name, camelCaseName) {
+        const routerTemplate = `import { Router } from 'express';
+import { ${camelCaseName}Controller } from '../controllers/${name}.controller';
+
+const router = Router();
+
+router.get('/', ${camelCaseName}Controller.findAll);
+router.get('/:id', ${camelCaseName}Controller.findOne);
+router.post('/', ${camelCaseName}Controller.create);
+router.put('/:id', ${camelCaseName}Controller.update);
+router.delete('/:id', ${camelCaseName}Controller.delete);
+
+export default router;
+`;
+        await fs_1.promises.writeFile(path_1.default.join(dir, `${name}.router.ts`), routerTemplate);
+    }
+}
+exports.default = new Commander();

package/dist/src/controller.d.ts

@@ -1,16 +1,28 @@
 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";
+import { InferInsertModel } from "drizzle-orm";
+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, 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 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>;
@@ -21,7 +33,7 @@ export declare class BaseController<T extends PgTable, FSchema extends z.ZodObje
     private filterSchema;
     private createSchema;
     private updateSchema;
-    constructor(service: CRUDService<FSchema>, base: z.ZodObject, filter: FSchema);
+    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>;

package/dist/src/controller.js

@@ -11,39 +11,50 @@ 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) {
+function createBuilder(service, schema, hook) {
     return validate(schema, async (req, res, data) => {
         const item = await service.create(data);
+        if (hook) {
+            const i = await hook(req, res, data, item);
+            return res.status(201).json(i);
+        }
         return res.status(201).json(item);
     });
 }
@@ -74,7 +85,7 @@ function getPagination(req) {
     };
 }
 class BaseController {
-    constructor(service, base, filter) {
+    constructor(service, base, filter, createSchema, updateSchema) {
         this.getAll = async (req, res) => {
             const filters = getFilters(req, this.filterSchema);
             const pagination = getPagination(req);
@@ -108,12 +119,12 @@ class BaseController {
         };
         this.service = service;
         // @ts-expect-error infer schema
-        this.createSchema = base.omit({
+        this.createSchema = createSchema || base.omit({
             id: true,
             deletedAt: true
         });
         // @ts-expect-error infer schema
-        this.updateSchema = base.partial();
+        this.updateSchema = updateSchema || base.partial();
         this.filterSchema = filter;
     }
 }

package/dist/src/filters.d.ts

@@ -1,4 +1,6 @@
 import { SQL } from "drizzle-orm";
-import { Filter, FilterMap } from "./types";
+import { Filter, FilterMap, PrimaryKeyData } from "./types";
 import { ZodObject } from "zod";
+import { AnyPgTable, PgColumn } from "drizzle-orm/pg-core";
 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,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.buildFilters = buildFilters;
+exports.buildPKFilters = buildPKFilters;
 const drizzle_orm_1 = require("drizzle-orm");
 function buildFilters(map, filters) {
     const conditions = [];
@@ -17,3 +18,10 @@ function buildFilters(map, filters) {
     }
     return conditions.length ? (0, drizzle_orm_1.and)(...conditions) : undefined;
 }
+function buildPKFilters(pks, values) {
+    if (pks.length === 0) {
+        throw new Error(`Table has no detectable primary keys`);
+    }
+    const conditions = pks.map(pk => (0, drizzle_orm_1.eq)(pk, values[pk.name]));
+    return conditions.length === 1 ? conditions[0] : (0, drizzle_orm_1.and)(...conditions);
+}

package/dist/src/service.d.ts

@@ -0,0 +1,24 @@
+import { Filter, FilterMap, PrimaryKeyData, PrimaryKeyType, Table } from "./types";
+import { PgSelect, PgTransaction } from "drizzle-orm/pg-core";
+import { NodePgDatabase } from "drizzle-orm/node-postgres";
+import { InferInsertModel, SQL } from "drizzle-orm";
+import { ZodObject } from "zod";
+export declare class ServiceBuilder<T extends Table, TSchema extends Record<string, unknown>, FSchema extends ZodObject> {
+    private readonly db;
+    private readonly table;
+    private readonly map;
+    private readonly pks;
+    readonly haveSoftDelete: boolean;
+    readonly findAllConditions: (f?: Filter<FSchema>) => SQL | undefined;
+    readonly findOneConditions: (id: PrimaryKeyType<T>) => SQL | undefined;
+    readonly tableName: string;
+    constructor(db: NodePgDatabase<TSchema>, table: T, map: FilterMap<FSchema>);
+    findOne<S extends PgSelect>(select: S): (pkFilter: PrimaryKeyData<T>) => 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>;
+    create(pre?: (data: any, tx?: PgTransaction<any, TSchema, any>) => Promise<InferInsertModel<T>>): (data: 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(): (id: PrimaryKeyType<T>, data: 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(): (id: PrimaryKeyType<T>, tx?: PgTransaction<any, TSchema, any>) => Promise<void>;
+    softDelete(): (id: PrimaryKeyType<T>, tx?: PgTransaction<any, TSchema, any>) => Promise<void>;
+    hardDelete(): (id: PrimaryKeyType<T>, tx?: PgTransaction<any, TSchema, any>) => Promise<void>;
+}

package/dist/src/service.js

@@ -0,0 +1,153 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ServiceBuilder = void 0;
+const pg_core_1 = require("drizzle-orm/pg-core");
+const drizzle_orm_1 = require("drizzle-orm");
+const filters_1 = require("./filters");
+const errors_1 = require("./errors");
+class ServiceBuilder {
+    constructor(db, table, map) {
+        this.db = db;
+        this.table = table;
+        this.tableName = (0, drizzle_orm_1.getTableName)(table);
+        this.pks = getPKs(table);
+        this.map = map;
+        this.haveSoftDelete = haveSoftDelete(table);
+        if (this.haveSoftDelete) {
+            this.findAllConditions = (f) => (0, drizzle_orm_1.and)((0, drizzle_orm_1.isNull)(this.table.deletedAt), (0, filters_1.buildFilters)(this.map, f));
+            this.findOneConditions = (id /* pkFilter: PrimaryKeyData<T> */) => (0, drizzle_orm_1.and)((0, drizzle_orm_1.isNull)(this.table.deletedAt), 
+            // buildPKFilters(this.pks, pkFilter)
+            (0, drizzle_orm_1.eq)(this.table.id, id));
+        }
+        else {
+            this.findAllConditions = (f) => (0, filters_1.buildFilters)(this.map, f);
+            this.findOneConditions = (id) => (0, drizzle_orm_1.eq)(this.table.id, id); // buildPKFilters(this.pks, id);
+        }
+    }
+    findOne(select) {
+        return async (pkFilter) => {
+            const result = await select.where(this.findOneConditions(pkFilter));
+            if (result.length == 0)
+                throw notFoundWithId(this.tableName, pkFilter);
+            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);
+            };
+        }
+        else {
+            return async (filters) => {
+                return await base(filters);
+            };
+        }
+    }
+    count() {
+        return async (filters) => {
+            const [result] = await this.db
+                .select({ count: (0, drizzle_orm_1.count)() })
+                .from(this.table)
+                .where(this.findAllConditions(filters));
+            return result.count;
+        };
+    }
+    create(pre) {
+        return async (data, tx) => {
+            if (pre) {
+                data = await pre(data);
+            }
+            const executor = tx || this.db;
+            const [result] = await executor
+                .insert(this.table)
+                .values(data)
+                .returning()
+                .catch(errors_1.handleSqlError);
+            return result;
+        };
+    }
+    update() {
+        return async (
+        // pkFilter: PrimaryKeyData<T>,
+        id, data, tx) => {
+            if (Object.keys(data).length == 0) {
+                throw new errors_1.BadRequest("update needs at least one field");
+            }
+            const executor = tx || this.db;
+            const [result] = await executor
+                .update(this.table)
+                .set(data)
+                .where(this.findOneConditions(id))
+                .returning()
+                .catch(errors_1.handleSqlError);
+            if (!result) {
+                throw notFoundWithId(this.tableName, { id: id });
+            }
+            return result;
+        };
+    }
+    delete() {
+        if (this.haveSoftDelete) {
+            return this.softDelete();
+        }
+        else {
+            return this.hardDelete();
+        }
+    }
+    softDelete() {
+        return async (id, tx) => {
+            const executor = tx || this.db;
+            const { rowCount } = await executor
+                .update(this.table)
+                .set({ deletedAt: new Date() })
+                .where(this.findOneConditions(id));
+            if (rowCount == 0) {
+                throw notFoundWithId(this.tableName, { id: id });
+            }
+        };
+    }
+    hardDelete() {
+        return async (
+        // id: PrimaryKeyData<T>,
+        id, tx) => {
+            const executor = tx || this.db;
+            const { rowCount } = await executor
+                .delete(this.table)
+                .where(this.findOneConditions(id));
+            if (rowCount == 0) {
+                throw notFoundWithId(this.tableName, { id: id });
+            }
+        };
+    }
+}
+exports.ServiceBuilder = ServiceBuilder;
+function haveSoftDelete(table, columnName = "deleted_at") {
+    const { columns } = (0, pg_core_1.getTableConfig)(table);
+    for (const col of columns) {
+        if (col.name == columnName) {
+            return true;
+        }
+    }
+    return false;
+}
+function getPKs(table) {
+    const pks = [];
+    const { columns } = (0, pg_core_1.getTableConfig)(table);
+    for (const col of columns) {
+        if (col.primary) {
+            pks.push(col);
+        }
+    }
+    if (pks.length <= 0)
+        throw new Error("Service builder needs at least one primary key field");
+    return pks;
+}
+function notFoundWithId(tableName, pkFilter) {
+    // TODO: proper message
+    return new errors_1.NotFound(`${tableName} not found`);
+}

package/dist/src/types.d.ts

@@ -1,21 +1,21 @@
 import { SQL } from "drizzle-orm";
-import { AnyPgTable, PgColumn, PgTable } from "drizzle-orm/pg-core";
+import { AnyPgTable, PgColumn, 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: any) => Promise<TTable["$inferSelect"]>;
+    findOne: (id: PrimaryKeyType<TTable>) => Promise<Partial<TTable>>;
 }
-export interface CreateService<TTable extends PgTable> {
-    create: (data: TTable["$inferInsert"]) => Promise<TTable["$inferSelect"]>;
+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> {
-    update: (id: any, data: Partial<TTable["$inferInsert"]>) => 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> {
-    delete: (id: 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 PrimaryKeyData<TTable extends AnyPgTable> = {
     [K in keyof TTable["_"]["columns"] as TTable["_"]["columns"][K] extends {
@@ -29,8 +29,8 @@ export interface PaginationParams {
     pageSize: number;
 }
 export type Table = AnyPgTable & {
-    id: PgColumn;
     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>> = {

package/package.json

@@ -1,9 +1,12 @@
 {
     "name": "bradb",
-    "version": "1.2.4",
+    "version": "2.0.0",
     "description": "",
     "main": "dist/index.js",
     "types": "dist/index.d.ts",
+    "bin": {
+        "brad": "dist/bin/brad.js"
+    },
     "files": [
         "dist"
     ],

package/dist/src/standard.d.ts

@@ -1,19 +0,0 @@
-import { Filter, FilterMap, PrimaryKeyType, Table } from "./types";
-import { PgSelect } from "drizzle-orm/pg-core";
-import { NodePgDatabase } from "drizzle-orm/node-postgres";
-import { InferInsertModel } from "drizzle-orm";
-import { ZodObject } from "zod";
-export declare class ServiceBuilder<T extends Table, TSchema extends Record<string, unknown>, FSchema extends ZodObject> {
-    private readonly db;
-    private readonly table;
-    private readonly map;
-    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][]>;
-    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>;
-    hardDelete(): (id: PrimaryKeyType<T>) => Promise<void>;
-    count(): (filters?: Filter<FSchema>) => Promise<number>;
-}

package/dist/src/standard.js

@@ -1,92 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ServiceBuilder = void 0;
-const drizzle_orm_1 = require("drizzle-orm");
-const filters_1 = require("./filters");
-const errors_1 = require("./errors");
-class ServiceBuilder {
-    constructor(db, table, map) {
-        this.db = db;
-        this.table = table;
-        this.tableName = (0, drizzle_orm_1.getTableName)(table);
-        this.map = map;
-    }
-    findOne(select) {
-        return async (id) => {
-            const result = await select.where((0, drizzle_orm_1.eq)(this.table.id, id));
-            if (result.length == 0)
-                throw notFoundWithId(this.tableName, id);
-            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);
-        };
-    }
-    create() {
-        return async (data) => {
-            const [result] = await this.db
-                .insert(this.table)
-                .values(data)
-                .returning()
-                .catch(errors_1.handleSqlError);
-            return result;
-        };
-    }
-    update() {
-        return async (id, data) => {
-            if (Object.keys(data).length == 0) {
-                throw new errors_1.BadRequest("update needs at least one field");
-            }
-            const [result] = await this.db
-                .update(this.table)
-                .set(data)
-                .where((0, drizzle_orm_1.eq)(this.table.id, id))
-                .returning()
-                .catch((e) => (0, errors_1.handleSqlError)(e));
-            if (!result) {
-                throw notFoundWithId(this.tableName, id);
-            }
-            return result;
-        };
-    }
-    softDelete() {
-        return async (id) => {
-            const { rowCount } = await this.db
-                .update(this.table)
-                .set({ deletedAt: new Date() })
-                .where((0, drizzle_orm_1.and)((0, drizzle_orm_1.eq)(this.table.id, id), (0, drizzle_orm_1.isNull)(this.table.deletedAt)));
-            if (rowCount == 0) {
-                throw notFoundWithId(this.tableName, id);
-            }
-        };
-    }
-    hardDelete() {
-        return async (id) => {
-            const { rowCount } = await this.db
-                .delete(this.table)
-                .where((0, drizzle_orm_1.eq)(this.table.id, id));
-            if (rowCount == 0) {
-                throw notFoundWithId(this.tableName, id);
-            }
-        };
-    }
-    count() {
-        return async (filters) => {
-            const [result] = await this.db
-                .select({ count: (0, drizzle_orm_1.count)() })
-                .from(this.table)
-                .where((0, drizzle_orm_1.and)((0, drizzle_orm_1.isNull)(this.table.deletedAt), (0, filters_1.buildFilters)(this.map, filters)));
-            return result.count;
-        };
-    }
-}
-exports.ServiceBuilder = ServiceBuilder;
-function notFoundWithId(tableName, id) {
-    return new errors_1.NotFound(`${tableName} with id ${id} not found`);
-}