bradb 2.2.0 → 3.0.0

package/dist/index.d.ts

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

package/dist/index.js

@@ -17,6 +17,5 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./src/types"), exports);
 __exportStar(require("./src/controller"), exports);
 __exportStar(require("./src/service"), exports);
-__exportStar(require("./src/relational"), exports);
 __exportStar(require("./src/filters"), exports);
 __exportStar(require("./src/errors"), exports);

package/dist/src/builder.d.ts

@@ -0,0 +1,17 @@
+import { BradConfig } from './config';
+export declare const nodeTypes: readonly ["validator", "controller", "service", "schema", "router", "filter", "db"];
+export type NodeType = typeof nodeTypes[number];
+type Node = {
+    name: string;
+    type: NodeType;
+    path: string;
+    adj: Node[];
+    exports: string[];
+};
+type Export = Record<string, any>;
+export declare let mods: Export;
+export declare function buildGraph(cfg: BradConfig, name: string, type: NodeType): Node;
+export declare function addNodeTo(cfg: BradConfig, name: string, type: NodeType, to: Node): Node;
+export declare function build(root: Node): void;
+export declare function destroy(root: Node): void;
+export {};

package/dist/src/builder.js

@@ -0,0 +1,182 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mods = exports.nodeTypes = void 0;
+exports.buildGraph = buildGraph;
+exports.addNodeTo = addNodeTo;
+exports.build = build;
+exports.destroy = destroy;
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const generators_1 = require("./generators");
+exports.nodeTypes = [
+    "validator", "controller", "service", "schema", "router", "filter", "db"
+];
+// Default and base dependecies for each node type
+const dependOn = {
+    router: ["controller"],
+    controller: ["service", "validator"],
+    service: ["schema", "filter", "db"],
+    validator: ["schema"],
+    filter: ["schema", "validator"],
+    schema: [],
+    db: []
+};
+// Default and base exports for each node type
+const requiredExports = {
+    validator: (name) => [`${name}Validator`],
+    service: (name) => [`${name}Service`],
+    controller: (name) => [`${name}Controller`],
+    schema: (name) => [`${name}Table`],
+    router: (name) => [`${name}Router`],
+    filter: (name) => [`${name}FilterMap`],
+    db: (name) => ["db"]
+};
+const generators = {
+    router: generators_1.generateRouter,
+    controller: generators_1.generateController,
+    validator: generators_1.generateValidator,
+    service: generators_1.generateService,
+    filter: generators_1.generateFilter,
+    schema: null,
+    db: null,
+};
+const visited = {};
+const checked = {};
+const valid = {};
+exports.mods = {};
+// Build the graph dependecies for a given name
+function buildGraph(cfg, name, type) {
+    const n = {
+        // TODO: refactor this
+        path: type == "db"
+            ? path_1.default.resolve(cfg.cwd, cfg.dbImportPath)
+            : pathTo(cfg, name, type),
+        name: name,
+        type: type,
+        adj: [],
+        exports: requiredExports[type](name)
+    };
+    if (!checked[id(n)]) {
+        checked[id(n)] = true;
+        try {
+            const mod = checkNode(n);
+            exports.mods = { ...exports.mods, ...mod };
+            valid[id(n)] = true;
+        }
+        catch (err) {
+            // If config is set to override = true we not check the modules and re-write anywise
+            if (!cfg.override) {
+                valid[id(n)] = true;
+            }
+            else {
+                console.error(err.message);
+                // it's not necessary to set it to false
+                valid[id(n)] = false;
+            }
+        }
+    }
+    for (const depType of dependOn[type]) {
+        const adj = buildGraph(cfg, n.name, depType);
+        n.adj.push(adj);
+    }
+    return n;
+}
+// Creates a new node directed to <to> node
+function addNodeTo(cfg, name, type, to) {
+    const n = {
+        path: type == "db"
+            ? path_1.default.resolve(cfg.cwd, cfg.dbImportPath)
+            : pathTo(cfg, name, type),
+        name: name,
+        type: type,
+        adj: [to],
+        exports: requiredExports[to.type](name)
+    };
+    return n;
+}
+function build(root) {
+    if (visited[id(root)]) {
+        return;
+    }
+    visited[id(root)] = true;
+    const importLines = [];
+    for (const dep of root.adj) {
+        importLines.push(buildImportLine(root, dep));
+        build(dep);
+    }
+    if (!valid[id(root)]) {
+        const gen = generators[root.type];
+        if (!gen) {
+            throw Error(`Missing generator for ${root.type}`);
+        }
+        console.log(`Generating ${root.name}.${root.type} ...`);
+        const table = exports.mods[`${root.name}Table`];
+        const code = gen(root.name, table, importLines);
+        fs_1.default.writeFileSync(root.path, code);
+    }
+}
+function destroy(root) {
+    for (const n of root.adj) {
+        destroy(n);
+    }
+    // We only delete the nodes with dependencies
+    // we are not going to delete schemas or db
+    if (root.adj.length > 0) {
+        const path = root.path;
+        try {
+            console.log(`Deleting ${path}...`);
+            fs_1.default.rmSync(path);
+        }
+        catch {
+            console.error(path, "does not exists");
+        }
+    }
+}
+/*
+    * Check if a Node exists and has it's exports
+    * @throws Error
+*/
+function checkNode(root) {
+    console.log(`Checking ${root.name}.${root.type}...`);
+    let module = {};
+    try {
+        module = require(root.path);
+    }
+    catch {
+        throw new Error(`[Missing file]: ${root.path}`);
+    }
+    for (const exp of root.exports) {
+        if (!module[exp]) {
+            throw new Error(`[Missing export]: Cannot import ${exp} from ${path_1.default}`);
+        }
+    }
+    return module;
+}
+function buildImportLine(from, to, maxColumns = 80) {
+    const relativePath = buildRelativeImport(from.path, to.path);
+    let sep = ' ';
+    let importLine = '';
+    let imports = to.exports.join(`,${sep}`);
+    importLine = `import {${sep}${imports}${sep}} from "${relativePath}"`;
+    if (importLine.length > maxColumns) {
+        sep = '\n\t';
+        imports = to.exports.join(`,${sep}`);
+        importLine = `import {${sep}${imports}${sep}} from "${relativePath}"`;
+    }
+    return importLine;
+}
+function pathTo(cfg, name, type) {
+    return path_1.default.resolve(cfg.cwd, dir(cfg, type), `${name}.${type}.ts`);
+}
+function removeExt(p) {
+    const parsed = path_1.default.parse(p);
+    return path_1.default.join(parsed.dir, parsed.name);
+}
+function buildRelativeImport(from, to) {
+    return path_1.default.relative(path_1.default.dirname(from), removeExt(to));
+}
+const dir = (cfg, type) => cfg[`${type}Dir`];
+const id = (n) => `${n.name}.${n.type}`;

package/dist/src/commands.d.ts

@@ -1,20 +1,2 @@
-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;
+#!/usr/bin/env node
+export {};

package/dist/src/commands.js

@@ -1,116 +1,39 @@
+#!/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 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();
+const commander_1 = require("commander");
+const builder_1 = require("./builder");
+const config_1 = require("./config");
+const program = new commander_1.Command();
+program.name("brad").description("BRAD - Generator");
+program
+    .command("generate")
+    .argument('<name>', 'name (singular) of entity')
+    .addArgument(new commander_1.Argument('<node-type>', 'Type of node to generate')
+    .choices(builder_1.nodeTypes)
+    .default("router"))
+    .option('-o, --override', 'Generator will override the current code', false)
+    .description("generate entity recursively")
+    .action(async (name, type, options) => {
+    const cfg = (0, config_1.loadConfig)();
+    cfg.override = options.override || false;
+    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));
+    (0, builder_1.build)(root);
+});
+program
+    .command("destroy")
+    .argument("<name>", "name of entity")
+    .addArgument(new commander_1.Argument('<node-type>', 'Type of Node to generate')
+    .choices(builder_1.nodeTypes)
+    .default("router"))
+    .description("destroy entity recursively")
+    .action(async (name, type) => {
+    const cfg = (0, config_1.loadConfig)();
+    const root = (0, builder_1.buildGraph)(cfg, name, type);
+    (0, builder_1.destroy)(root);
+});
+program.parseAsync(process.argv);

package/dist/src/config.d.ts

@@ -0,0 +1,16 @@
+import { z } from "zod";
+declare const ConfigSchema: z.ZodObject<{
+    dbImportPath: z.ZodDefault<z.ZodString>;
+    validatorDir: z.ZodDefault<z.ZodString>;
+    schemaDir: z.ZodDefault<z.ZodString>;
+    serviceDir: z.ZodDefault<z.ZodString>;
+    controllerDir: z.ZodDefault<z.ZodString>;
+    routerDir: z.ZodDefault<z.ZodString>;
+    filterDir: z.ZodDefault<z.ZodString>;
+    cwd: z.ZodDefault<z.ZodString>;
+    maxColumns: z.ZodDefault<z.ZodNumber>;
+    override: z.ZodDefault<z.ZodCoercedBoolean<unknown>>;
+}, z.core.$strip>;
+export type BradConfig = z.infer<typeof ConfigSchema>;
+export declare function loadConfig(customPath?: string): BradConfig;
+export {};

package/dist/src/config.js

@@ -0,0 +1,43 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadConfig = loadConfig;
+const path_1 = __importDefault(require("path"));
+const zod_1 = require("zod");
+const fs_1 = __importDefault(require("fs"));
+const ConfigSchema = zod_1.z.object({
+    dbImportPath: zod_1.z.string().default("src/db.ts"),
+    validatorDir: zod_1.z.string().default("src/validators"),
+    schemaDir: zod_1.z.string().default("src/schemas"),
+    serviceDir: zod_1.z.string().default("src/services"),
+    controllerDir: zod_1.z.string().default("src/controllers"),
+    routerDir: zod_1.z.string().default("src/routes"),
+    filterDir: zod_1.z.string().default("src/filters"),
+    cwd: zod_1.z.string().default(process.cwd()),
+    maxColumns: zod_1.z.number().default(80),
+    override: zod_1.z.coerce.boolean().default(false)
+});
+function loadConfig(customPath) {
+    const configName = "brad.config.json";
+    const filePath = path_1.default.resolve(process.cwd(), configName);
+    try {
+        const file = fs_1.default.readFileSync(filePath, 'utf8');
+        return ConfigSchema.parse(JSON.parse(file));
+    }
+    catch (err) {
+        if (err instanceof zod_1.ZodError) {
+            error(err.message);
+        }
+        else if (err instanceof SyntaxError) {
+            error("File is not a valid JSON");
+        }
+        error('No config found. Create brad.config.json');
+        process.exit(2);
+    }
+}
+function error(msg) {
+    console.error(`\x1b[41m${msg}\x1b[0m`);
+    process.exit(2);
+}

package/dist/src/filters.d.ts

@@ -2,5 +2,8 @@ import { SQL } from "drizzle-orm";
 import { Filter, FilterMap, PrimaryKeyData } from "./types";
 import { ZodObject } from "zod";
 import { AnyPgTable, PgColumn } from "drizzle-orm/pg-core";
+export declare const createFilterSchema: import("drizzle-zod").CreateInsertSchema<{
+    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,8 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+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)({
+    coerce: {
+        number: true,
+    },
+});
+exports.createFilterSchema = createInsertSchema;
 function buildFilters(map, filters) {
     const conditions = [];
     if (!filters)

package/dist/src/generators.d.ts

@@ -0,0 +1,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 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

@@ -0,0 +1,164 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateRouter = generateRouter;
+exports.generateValidator = generateValidator;
+exports.generateController = generateController;
+exports.generateService = generateService;
+exports.generateFilter = generateFilter;
+exports.getRelationName = getRelationName;
+const pg_core_1 = require("drizzle-orm/pg-core");
+const pg_1 = require("./pg");
+function generateRouter(name, table, imports) {
+    const pkColumns = (0, pg_1.getPKs)(table);
+    const route = pkColumns.map(pk => `${getRelationName(pk.name)}/:${pk.name}`).join("/");
+    return `import { Router } from "express";
+${imports.join('\n')};
+export const ${name}Router = Router();
+
+// Get All
+${name}Router.get("/", ${name}Controller.getAll);
+
+// Create
+${name}Router.post("/", ${name}Controller.create);
+
+// Get one
+${name}Router.get("${route}", ${name}Controller.getOne);
+
+// Update
+${name}Router.put("${route}", ${name}Controller.update);
+
+// Delete
+${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 { z } from "zod";
+${imports.join('\n')};
+
+const select = createSelectSchema(${name}Table);
+const insert = createInsertSchema(${name}Table);
+const update = insert.partial();
+const filter = createFilterSchema(${name}Table).partial();
+const pk = select.pick({
+    ${zodPkPicker}
+});
+
+type ${capitalize(name)} = z.infer<typeof select>;
+type ${capitalize(name)}Insert = z.infer<typeof insert>;
+type ${capitalize(name)}Update = z.infer<typeof update>;
+type ${capitalize(name)}Filter = z.infer<typeof filter>;
+type ${capitalize(name)}Pk = z.infer<typeof pk>;
+
+export const ${name}Validator = {
+    select,
+    insert,
+    update,
+    filter,
+    pk
+};`;
+}
+function generateController(name, table, imports) {
+    return `import { Request, Response } from "express";
+${imports.join('\n')};
+
+async function getAll(req: Request, res: Response) {
+    const filters = ${name}Validator.filter.parse(req.query);
+    const items = await ${name}Service.findAll(filters);
+    const total = await ${name}Service.count(filters);
+
+    res.json({
+        items,
+        total
+    });
+}
+
+async function getOne(req: Request, res: Response) {
+    const pk = ${name}Validator.pk.parse(req.params);
+    const item = await ${name}Service.findOne(pk);
+    res.json(item);
+}
+
+async function create(req: Request, res: Response) {
+    const data = ${name}Validator.insert.parse(req.body);
+    const item = await ${name}Service.create(data);
+    res.status(201).json(item);
+}
+
+async function update(req: Request, res: Response) {
+    const pk = ${name}Validator.pk.parse(req.params);
+    const data = ${name}Validator.update.parse(req.body);
+    const item = await ${name}Service.update(pk, data);
+    res.status(200).json(item);
+}
+
+async function remove(req: Request, res: Response) {
+    const pk = ${name}Validator.pk.parse(req.params);
+    await ${name}Service.delete(pk);
+    res.status(204).send();
+}
+
+export const ${name}Controller = {
+    getAll,
+    getOne,
+    create,
+    update,
+    remove
+};`;
+}
+function generateService(name, table, imports) {
+    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)
+};`;
+}
+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');
+    return `import { FilterMap } from "bradb";
+import { eq } from "drizzle-orm";
+${imports.join('\n')};
+
+export const ${name}FilterMap: FilterMap<typeof ${name}Validator.filter> = {
+    ${filters}
+}`;
+}
+function getRelationName(fkName) {
+    const parts = fkName.split('id');
+    if (parts.length < 2) {
+        throw new Error("fkName must have name like 'id{Entity}'");
+    }
+    return parts[1].toLowerCase();
+}
+function buildArgs(columns) {
+    let args = [];
+    for (const col of columns) {
+        args.push(`${col.name}: ${col.dataType}`);
+    }
+    return args.join(', ');
+}
+function buildZodPkPicker(pks) {
+    return pks.map(pk => `${pk.name}: true`).join(',\n\t');
+}
+function capitalize(s) {
+    if (typeof s !== 'string' || !s || s.length == 0) {
+        return '';
+    }
+    return s[0].toUpperCase() + s.slice(1);
+}

package/dist/src/pg.d.ts

@@ -0,0 +1,3 @@
+import { PgTable } from 'drizzle-orm/pg-core';
+export declare function getFkNames(table: PgTable): import("drizzle-orm/pg-core").ForeignKey[];
+export declare function getPKs(table: PgTable): import("drizzle-orm/pg-core").PgColumn<import("drizzle-orm").ColumnBaseConfig<import("drizzle-orm").ColumnDataType, string>, {}, {}>[];

package/dist/src/pg.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getFkNames = getFkNames;
+exports.getPKs = getPKs;
+const pg_core_1 = require("drizzle-orm/pg-core");
+function getFkNames(table) {
+    const { foreignKeys } = (0, pg_core_1.getTableConfig)(table);
+    return foreignKeys.map(fk => fk);
+}
+function getPKs(table) {
+    const { columns, primaryKeys } = (0, pg_core_1.getTableConfig)(table);
+    if (primaryKeys.length > 0) {
+        // TODO: for now we pick the first pk
+        return primaryKeys[0].columns;
+    }
+    let pks = [];
+    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 isDrizzleTable(obj) {
+    return obj &&
+        typeof obj === 'object' &&
+        obj instanceof pg_core_1.PgTable;
+}

package/dist/src/service.d.ts

@@ -1,24 +1,24 @@
-import { Filter, FilterMap, PrimaryKeyType, Table } from "./types";
-import { PgSelect, PgTransaction } from "drizzle-orm/pg-core";
+import { Filter, FilterMap, PrimaryKeyData } from "./types";
+import { AnyPgTable, PgColumn, 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> {
+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;
     private readonly map;
-    private readonly pks;
+    readonly pks: PgColumn[];
     readonly haveSoftDelete: boolean;
     readonly findAllConditions: (f?: Filter<FSchema>) => SQL | undefined;
-    readonly findOneConditions: (id: PrimaryKeyType<T>) => SQL | undefined;
+    readonly findOneConditions: (pkFilter: PKType) => SQL | undefined;
     readonly tableName: string;
     constructor(db: NodePgDatabase<TSchema>, table: T, map: FilterMap<FSchema>);
-    findOne<S extends PgSelect>(select: S): (id: PrimaryKeyType<T>) => Promise<Awaited<ReturnType<S["execute"]>>[number]>;
+    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>;
     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 : InferInsertModel<T>, tx?: PgTransaction<any, TSchema, any>) => Promise<InferInsertModel<T>>): (id: PrimaryKeyType<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>;
-    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>;
+    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>;
 }

package/dist/src/service.js

@@ -5,30 +5,29 @@ 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");
+const pg_1 = require("./pg");
 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.pks = (0, pg_1.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));
+            this.findOneConditions = (pkFilter) => (0, drizzle_orm_1.and)((0, drizzle_orm_1.isNull)(this.table.deletedAt), (0, filters_1.buildPKFilters)(this.pks, pkFilter));
         }
         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);
+            this.findOneConditions = (pkFilter) => (0, filters_1.buildPKFilters)(this.pks, pkFilter);
         }
     }
     findOne(select) {
-        return async (id /* pkFilter: PrimaryKeyData<T> */) => {
-            const result = await select.where(this.findOneConditions(id));
+        return async (pkValues) => {
+            const result = await select.where(this.findOneConditions(pkValues));
             if (result.length == 0)
-                throw notFoundWithId(this.tableName, { id: id });
+                throw notFoundWithId(this.tableName, pkValues);
             return result[0];
         };
     }
@@ -74,7 +73,7 @@ class ServiceBuilder {
         };
     }
     update(pre) {
-        return async (id, data, tx) => {
+        return async (pks, data, tx) => {
             let values = data;
             if (pre) {
                 values = await pre(data);
@@ -86,11 +85,11 @@ class ServiceBuilder {
             const [result] = await executor
                 .update(this.table)
                 .set(values)
-                .where(this.findOneConditions(id))
+                .where(this.findOneConditions(pks))
                 .returning()
                 .catch(errors_1.handleSqlError);
             if (!result) {
-                throw notFoundWithId(this.tableName, { id: id });
+                throw notFoundWithId(this.tableName, pks);
             }
             return result;
         };
@@ -104,27 +103,25 @@ class ServiceBuilder {
         }
     }
     softDelete() {
-        return async (id, tx) => {
+        return async (pks, tx) => {
             const executor = tx || this.db;
             const { rowCount } = await executor
                 .update(this.table)
                 .set({ deletedAt: new Date() })
-                .where(this.findOneConditions(id));
+                .where(this.findOneConditions(pks));
             if (rowCount == 0) {
-                throw notFoundWithId(this.tableName, { id: id });
+                throw notFoundWithId(this.tableName, pks);
             }
         };
     }
     hardDelete() {
-        return async (
-        // id: PrimaryKeyData<T>,
-        id, tx) => {
+        return async (pks, tx) => {
             const executor = tx || this.db;
             const { rowCount } = await executor
                 .delete(this.table)
-                .where(this.findOneConditions(id));
+                .where(this.findOneConditions(pks));
             if (rowCount == 0) {
-                throw notFoundWithId(this.tableName, { id: id });
+                throw notFoundWithId(this.tableName, pks);
             }
         };
     }
@@ -139,22 +136,7 @@ function haveSoftDelete(table, columnName = "deleted_at") {
     }
     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) {
-    // for (const [key, val] of pkFilter.values()) {
-    //
-    // }
-    // TODO: proper message
-    return new errors_1.NotFound(`${tableName} not found`);
+    const message = Object.entries(pkFilter).map(([k, v]) => `${k}=${v}`).join(' and ');
+    return new errors_1.NotFound(`${tableName} with ${message} not found`);
 }

package/package.json

@@ -1,18 +1,20 @@
 {
     "name": "bradb",
-    "version": "2.2.0",
+    "version": "3.0.0",
     "description": "",
     "main": "dist/index.js",
     "types": "dist/index.d.ts",
     "bin": {
-        "brad": "dist/bin/brad.js"
+        "brad": "dist/src/commands.js"
     },
     "files": [
         "dist"
     ],
     "scripts": {
         "build": "rm -rf dist/ && tsc",
-        "test": "echo \"Error: no test specified\" && exit 1"
+        "test": "vitest",
+        "yalc:publish": "npm run build && npx yalc publish",
+        "yalc:push": "npm run build && chmod +x dist/src/commands.js && npx yalc push"
     },
     "keywords": [
         "api",
@@ -24,13 +26,21 @@
     "devDependencies": {
         "@types/express": "^5.0.3",
         "@types/pg": "^8.15.5",
-        "typescript": "^5.9.2"
+        "drizzle-kit": "^0.31.7",
+        "ts-node": "^10.9.2",
+        "tsd": "^0.33.0",
+        "typescript": "^5.9.2",
+        "vitest": "^3.2.4"
     },
     "peerDependencies": {
         "@types/pg": "^8.15.5",
-        "drizzle-orm": "^0.44.5",
+        "drizzle-orm": "^0.44.4",
+        "drizzle-zod": "^0.8.3",
         "express": "^5.1.0",
         "pg": "^8.16.3",
         "zod": "^4.1.5"
+    },
+    "dependencies": {
+        "commander": "^14.0.3"
     }
 }

package/dist/bin/brad.d.ts

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

package/dist/bin/brad.js

@@ -1,52 +0,0 @@
-#!/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/src/relational.d.ts

@@ -1,8 +0,0 @@
-import { Filter, FilterMap } from "../src/types";
-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?: KnownKeysOnly<TSelection, Omit<DBQueryConfig<"many", true, TSchema, TFields>, "limit">>): (id: number) => Promise<BuildQueryResult<TSchema, TFields, TSelection>>;
-};

package/dist/src/relational.js

@@ -1,53 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RelationalBuilder = RelationalBuilder;
-const drizzle_orm_1 = require("drizzle-orm");
-const filters_1 = require("./filters");
-const errors_1 = require("./errors");
-const pg_core_1 = require("drizzle-orm/pg-core");
-function RelationalBuilder(q, filterMap) {
-    const baseWhere = (table) => (0, drizzle_orm_1.isNull)(table.deletedAt);
-    return {
-        findAll(config) {
-            return async (filters, page = 1, pageSize = 10) => {
-                const offset = (page - 1) * pageSize;
-                const items = q.findMany({
-                    ...config,
-                    where: (table) => (0, drizzle_orm_1.and)(baseWhere(table), (0, filters_1.buildFilters)(filterMap, filters)),
-                    limit: pageSize,
-                    offset
-                });
-                return items;
-            };
-        },
-        findOne(config) {
-            return async (id) => {
-                const result = await q.findFirst({
-                    ...config,
-                    // TODO: Validate table contains 'id' field
-                    where: (table, { eq }) => (0, drizzle_orm_1.and)(baseWhere(table), eq(table.id, id))
-                });
-                if (!result) {
-                    // TODO: proper name
-                    const t = "record";
-                    throw new errors_1.NotFound(`${t} with id ${id} not found`);
-                }
-                return result;
-            };
-        }
-    };
-}
-function findByPkConditions(table, data) {
-    const { primaryKeys } = (0, pg_core_1.getTableConfig)(table);
-    const conditions = [];
-    for (const pk of primaryKeys) {
-        for (const column of pk.columns) {
-            const name = column.name;
-            // if (data[name] === undefined || data[name] === null) {
-            //     throw new Error(`Missing value for pk column: ${column.name}`);
-            // }
-            conditions.push((0, drizzle_orm_1.eq)(table[name], data[name]));
-        }
-    }
-    return conditions;
-}