bradb 1.2.1 → 1.2.2

package/dist/index.d.ts

@@ -2,5 +2,5 @@ export * from './src/types';
 export * from './src/controller';
 export * from './src/standard';
 export * from './src/relational';
-export * from './src/utils';
+export * from './src/filters';
 export * from './src/errors';

package/dist/index.js

@@ -18,5 +18,5 @@ __exportStar(require("./src/types"), exports);
 __exportStar(require("./src/controller"), exports);
 __exportStar(require("./src/standard"), exports);
 __exportStar(require("./src/relational"), exports);
-__exportStar(require("./src/utils"), exports);
+__exportStar(require("./src/filters"), exports);
 __exportStar(require("./src/errors"), exports);

package/dist/src/controller.d.ts

@@ -2,12 +2,12 @@ import { PgTable } from "drizzle-orm/pg-core";
 import { Request, Response } from "express";
 import { z } from "zod";
 import { CRUDService } from "./types";
-export declare class BaseController<T extends PgTable> {
-    protected service: CRUDService;
-    private schema;
+export declare class BaseController<T extends PgTable, FSchema extends z.ZodObject> {
+    protected service: CRUDService<FSchema>;
+    private filterSchema;
     private createSchema;
     private updateSchema;
-    constructor(service: CRUDService, base: z.ZodObject, filter: z.ZodSchema<Partial<T["$inferSelect"]>>);
+    constructor(service: CRUDService<FSchema>, base: z.ZodObject, filter: FSchema);
     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

@@ -4,10 +4,10 @@ exports.BaseController = void 0;
 class BaseController {
     constructor(service, base, filter) {
         this.getAll = async (req, res) => {
-            const filters = getFilters(req, this.schema.filter);
+            const filters = getFilters(req, this.filterSchema);
             const pagination = getPagination(req);
             const [items, total] = await Promise.all([
-                this.service.findAll({ pagination, filters }),
+                this.service.findAll(filters, pagination.page, pagination.pageSize),
                 this.service.count(filters)
             ]);
             res.status(200).json({
@@ -42,7 +42,7 @@ class BaseController {
         });
         // @ts-expect-error infer schema
         this.updateSchema = base.partial();
-        this.schema = { base, filter };
+        this.filterSchema = filter;
     }
 }
 exports.BaseController = BaseController;

package/dist/src/filters.d.ts

@@ -0,0 +1,4 @@
+import { SQL } from "drizzle-orm";
+import { Filter, FilterMap } from "./types";
+import { ZodObject } from "zod";
+export declare function buildFilters<FSchema extends ZodObject>(map: FilterMap<FSchema>, filters?: Filter<FSchema>): SQL<unknown> | undefined;

package/dist/src/filters.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildFilters = buildFilters;
+const drizzle_orm_1 = require("drizzle-orm");
+function buildFilters(map, filters) {
+    const conditions = [];
+    if (!filters)
+        return undefined;
+    for (const f of Object.keys(filters)) {
+        if (f in map) {
+            const func = map[f];
+            const value = filters[f];
+            if (value !== undefined && value !== null) {
+                conditions.push(func(value));
+            }
+        }
+    }
+    return conditions.length ? (0, drizzle_orm_1.and)(...conditions) : undefined;
+}

package/dist/src/relational.d.ts

@@ -1,5 +1,8 @@
-import { FilterMap, FindAllOptions } from "../src/types";
-import { DBQueryConfig, TableRelationalConfig, TablesRelationalConfig } from "drizzle-orm";
+import { Filter, FilterMap } from "../src/types";
+import { BuildQueryResult, DBQueryConfig, TableRelationalConfig, TablesRelationalConfig } from "drizzle-orm";
 import { RelationalQueryBuilder } from "drizzle-orm/pg-core/query-builders/query";
-export declare function findAllRelational<TSchema extends TablesRelationalConfig, TFields extends TableRelationalConfig, TTableConfig extends TableRelationalConfig = TableRelationalConfig>(map: FilterMap<any>, q: RelationalQueryBuilder<TSchema, TFields>, config: DBQueryConfig<any, true, TSchema, TTableConfig>): (options: FindAllOptions<any>) => Promise<(({ [K_1 in keyof TTableConfig["columns"]]?: boolean | undefined; } | undefined extends Record<string, unknown> ? { [Key in (import("drizzle-orm").Equal<Exclude<(Record<string, unknown> & { [K_1 in keyof TTableConfig["columns"]]?: boolean | undefined; })[(string | keyof TTableConfig["columns"]) & keyof TFields["columns"]], undefined>, false> extends true ? Exclude<keyof TFields["columns"], import("drizzle-orm").NonUndefinedKeysOnly<Record<string, unknown> & { [K_1 in keyof TTableConfig["columns"]]?: boolean | undefined; }>> : { [K_3 in keyof (Record<string, unknown> & { [K_1 in keyof TTableConfig["columns"]]?: boolean | undefined; })]: import("drizzle-orm").Equal<(Record<string, unknown> & { [K_1 in keyof TTableConfig["columns"]]?: boolean | undefined; })[K_3], true> extends true ? K_3 : never; }[string | keyof TTableConfig["columns"]] & keyof TFields["columns"]) & string as Key]: { [K_4 in import("drizzle-orm").Equal<Exclude<(Record<string, unknown> & { [K_1 in keyof TTableConfig["columns"]]?: boolean | undefined; })[(string | keyof TTableConfig["columns"]) & keyof TFields["columns"]], undefined>, false> extends true ? Exclude<keyof TFields["columns"], import("drizzle-orm").NonUndefinedKeysOnly<Record<string, unknown> & { [K_1 in keyof TTableConfig["columns"]]?: boolean | undefined; }>> : { [K_3 in keyof (Record<string, unknown> & { [K_1 in keyof TTableConfig["columns"]]?: boolean | undefined; })]: import("drizzle-orm").Equal<(Record<string, unknown> & { [K_1 in keyof TTableConfig["columns"]]?: boolean | undefined; })[K_3], true> extends true ? K_3 : never; }[string | keyof TTableConfig["columns"]] & keyof TFields["columns"]]: TFields["columns"][K_4]; }[Key]["_"]["notNull"] extends true ? { [K_4 in import("drizzle-orm").Equal<Exclude<(Record<string, unknown> & { [K_1 in keyof TTableConfig["columns"]]?: boolean | undefined; })[(string | keyof TTableConfig["columns"]) & keyof TFields["columns"]], undefined>, false> extends true ? Exclude<keyof TFields["columns"], import("drizzle-orm").NonUndefinedKeysOnly<Record<string, unknown> & { [K_1 in keyof TTableConfig["columns"]]?: boolean | undefined; }>> : { [K_3 in keyof (Record<string, unknown> & { [K_1 in keyof TTableConfig["columns"]]?: boolean | undefined; })]: import("drizzle-orm").Equal<(Record<string, unknown> & { [K_1 in keyof TTableConfig["columns"]]?: boolean | undefined; })[K_3], true> extends true ? K_3 : never; }[string | keyof TTableConfig["columns"]] & keyof TFields["columns"]]: TFields["columns"][K_4]; }[Key]["_"]["data"] : { [K_4 in import("drizzle-orm").Equal<Exclude<(Record<string, unknown> & { [K_1 in keyof TTableConfig["columns"]]?: boolean | undefined; })[(string | keyof TTableConfig["columns"]) & keyof TFields["columns"]], undefined>, false> extends true ? Exclude<keyof TFields["columns"], import("drizzle-orm").NonUndefinedKeysOnly<Record<string, unknown> & { [K_1 in keyof TTableConfig["columns"]]?: boolean | undefined; }>> : { [K_3 in keyof (Record<string, unknown> & { [K_1 in keyof TTableConfig["columns"]]?: boolean | undefined; })]: import("drizzle-orm").Equal<(Record<string, unknown> & { [K_1 in keyof TTableConfig["columns"]]?: boolean | undefined; })[K_3], true> extends true ? K_3 : never; }[string | keyof TTableConfig["columns"]] & keyof TFields["columns"]]: TFields["columns"][K_4]; }[Key]["_"]["data"] | null; } extends infer T_1 ? { [K_2 in keyof T_1]: T_1[K_2]; } : never : { [Key_1 in keyof TFields["columns"] & string as Key_1]: TFields["columns"][Key_1]["_"]["notNull"] extends true ? TFields["columns"][Key_1]["_"]["data"] : TFields["columns"][Key_1]["_"]["data"] | null; } extends infer T_2 ? { [K_4 in keyof T_2]: T_2[K_4]; } : never) & {} & ({ [K_5 in keyof TTableConfig["relations"]]?: true | DBQueryConfig<TTableConfig["relations"][K_5] extends import("drizzle-orm").One<string, boolean> ? "one" : "many", false, TSchema, import("drizzle-orm").FindTableByDBName<TSchema, TTableConfig["relations"][K_5]["referencedTableName"]>> | undefined; } | undefined extends Record<string, unknown> ? import("drizzle-orm").BuildRelationResult<TSchema, Record<string, unknown> & { [K_5 in keyof TTableConfig["relations"]]?: true | DBQueryConfig<TTableConfig["relations"][K_5] extends import("drizzle-orm").One<string, boolean> ? "one" : "many", false, TSchema, import("drizzle-orm").FindTableByDBName<TSchema, TTableConfig["relations"][K_5]["referencedTableName"]>> | undefined; }, TFields["relations"]> : {}) extends infer T ? { [K in keyof T]: T[K]; } : never)[]>;
-export declare function findOneRelational<TSchema extends TablesRelationalConfig, TFields extends TableRelationalConfig, TTableConfig extends TableRelationalConfig = TableRelationalConfig>(q: RelationalQueryBuilder<TSchema, TFields>, config: DBQueryConfig<any, true, TSchema, TTableConfig>): (id: number) => Promise<({ [K_1 in keyof TTableConfig["columns"]]?: boolean | undefined; } | undefined extends Record<string, unknown> ? { [Key in (import("drizzle-orm").Equal<Exclude<(Record<string, unknown> & { [K_1 in keyof TTableConfig["columns"]]?: boolean | undefined; })[(string | keyof TTableConfig["columns"]) & keyof TFields["columns"]], undefined>, false> extends true ? Exclude<keyof TFields["columns"], import("drizzle-orm").NonUndefinedKeysOnly<Record<string, unknown> & { [K_1 in keyof TTableConfig["columns"]]?: boolean | undefined; }>> : { [K_3 in keyof (Record<string, unknown> & { [K_1 in keyof TTableConfig["columns"]]?: boolean | undefined; })]: import("drizzle-orm").Equal<(Record<string, unknown> & { [K_1 in keyof TTableConfig["columns"]]?: boolean | undefined; })[K_3], true> extends true ? K_3 : never; }[string | keyof TTableConfig["columns"]] & keyof TFields["columns"]) & string as Key]: { [K_4 in import("drizzle-orm").Equal<Exclude<(Record<string, unknown> & { [K_1 in keyof TTableConfig["columns"]]?: boolean | undefined; })[(string | keyof TTableConfig["columns"]) & keyof TFields["columns"]], undefined>, false> extends true ? Exclude<keyof TFields["columns"], import("drizzle-orm").NonUndefinedKeysOnly<Record<string, unknown> & { [K_1 in keyof TTableConfig["columns"]]?: boolean | undefined; }>> : { [K_3 in keyof (Record<string, unknown> & { [K_1 in keyof TTableConfig["columns"]]?: boolean | undefined; })]: import("drizzle-orm").Equal<(Record<string, unknown> & { [K_1 in keyof TTableConfig["columns"]]?: boolean | undefined; })[K_3], true> extends true ? K_3 : never; }[string | keyof TTableConfig["columns"]] & keyof TFields["columns"]]: TFields["columns"][K_4]; }[Key]["_"]["notNull"] extends true ? { [K_4 in import("drizzle-orm").Equal<Exclude<(Record<string, unknown> & { [K_1 in keyof TTableConfig["columns"]]?: boolean | undefined; })[(string | keyof TTableConfig["columns"]) & keyof TFields["columns"]], undefined>, false> extends true ? Exclude<keyof TFields["columns"], import("drizzle-orm").NonUndefinedKeysOnly<Record<string, unknown> & { [K_1 in keyof TTableConfig["columns"]]?: boolean | undefined; }>> : { [K_3 in keyof (Record<string, unknown> & { [K_1 in keyof TTableConfig["columns"]]?: boolean | undefined; })]: import("drizzle-orm").Equal<(Record<string, unknown> & { [K_1 in keyof TTableConfig["columns"]]?: boolean | undefined; })[K_3], true> extends true ? K_3 : never; }[string | keyof TTableConfig["columns"]] & keyof TFields["columns"]]: TFields["columns"][K_4]; }[Key]["_"]["data"] : { [K_4 in import("drizzle-orm").Equal<Exclude<(Record<string, unknown> & { [K_1 in keyof TTableConfig["columns"]]?: boolean | undefined; })[(string | keyof TTableConfig["columns"]) & keyof TFields["columns"]], undefined>, false> extends true ? Exclude<keyof TFields["columns"], import("drizzle-orm").NonUndefinedKeysOnly<Record<string, unknown> & { [K_1 in keyof TTableConfig["columns"]]?: boolean | undefined; }>> : { [K_3 in keyof (Record<string, unknown> & { [K_1 in keyof TTableConfig["columns"]]?: boolean | undefined; })]: import("drizzle-orm").Equal<(Record<string, unknown> & { [K_1 in keyof TTableConfig["columns"]]?: boolean | undefined; })[K_3], true> extends true ? K_3 : never; }[string | keyof TTableConfig["columns"]] & keyof TFields["columns"]]: TFields["columns"][K_4]; }[Key]["_"]["data"] | null; } extends infer T_1 ? { [K_2 in keyof T_1]: T_1[K_2]; } : never : { [Key_1 in keyof TFields["columns"] & string as Key_1]: TFields["columns"][Key_1]["_"]["notNull"] extends true ? TFields["columns"][Key_1]["_"]["data"] : TFields["columns"][Key_1]["_"]["data"] | null; } extends infer T_2 ? { [K_4 in keyof T_2]: T_2[K_4]; } : never) & {} & ({ [K_5 in keyof TTableConfig["relations"]]?: true | DBQueryConfig<TTableConfig["relations"][K_5] extends import("drizzle-orm").One<string, boolean> ? "one" : "many", false, TSchema, import("drizzle-orm").FindTableByDBName<TSchema, TTableConfig["relations"][K_5]["referencedTableName"]>> | undefined; } | undefined extends Record<string, unknown> ? import("drizzle-orm").BuildRelationResult<TSchema, Record<string, unknown> & { [K_5 in keyof TTableConfig["relations"]]?: true | DBQueryConfig<TTableConfig["relations"][K_5] extends import("drizzle-orm").One<string, boolean> ? "one" : "many", false, TSchema, import("drizzle-orm").FindTableByDBName<TSchema, TTableConfig["relations"][K_5]["referencedTableName"]>> | undefined; }, TFields["relations"]> : {}) extends infer T ? { [K in keyof T]: T[K]; } : never>;
+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>>;
+};

package/dist/src/relational.js

@@ -1,34 +1,53 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.findAllRelational = findAllRelational;
-exports.findOneRelational = findOneRelational;
+exports.RelationalBuilder = RelationalBuilder;
 const drizzle_orm_1 = require("drizzle-orm");
-const utils_1 = require("./utils");
-function findAllRelational(map, q, config) {
-    return async (options) => {
-        const { offset, limit } = (0, utils_1.getPagination)(options);
-        const conditions = (0, utils_1.getConditions)(options, map);
-        const items = q.findMany({
-            ...config,
-            where: (table, { isNull }) => (0, drizzle_orm_1.and)(isNull(table.deletedAt), ...conditions),
-            limit: limit,
-            offset: offset
-        });
-        return items;
+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 findOneRelational(q, config) {
-    return async (id) => {
-        const result = await q.findFirst({
-            ...config,
-            // TODO: Validate table contains 'id' field
-            where: (table, { eq, isNull }) => (0, drizzle_orm_1.and)(isNull(table.deletedAt), eq(table.id, id))
-        });
-        if (!result) {
-            // TODO: proper name
-            const t = "tabla";
-            throw new Error(`${t} with id ${id} not found`);
+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 result;
-    };
+    }
+    return conditions;
 }

package/dist/src/standard.d.ts

@@ -1,24 +1,19 @@
-import { Filter, FilterMap, FindAllOptions, PrimaryKeyType, Table } from "./types";
+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";
-export declare class ServiceBuilder<T extends Table, TSchema extends Record<string, unknown>> {
+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<T>);
-    findOne<S extends PgSelect>(select: S): (id: number) => Promise<{
-        [x: string]: any;
-    } | {
-        [x: string]: any;
-    } | {
-        [x: string]: any;
-    }>;
-    findAll<S extends PgSelect<T["_"]["name"]>>(select: S): (options: FindAllOptions<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)[]>;
+    constructor(db: NodePgDatabase<TSchema>, table: T, map: FilterMap<FSchema>);
+    findOne<S extends PgSelect>(select: S): (id: number) => Promise<S>;
+    findAll<S extends PgSelect>(select: S): (filters?: Filter<FSchema>, page?: number, pageSize?: number) => Promise<S>;
     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<T>) => Promise<number>;
+    count(): (filters?: Filter<FSchema>) => Promise<number>;
 }

package/dist/src/standard.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ServiceBuilder = void 0;
 const drizzle_orm_1 = require("drizzle-orm");
-const utils_1 = require("./utils");
+const filters_1 = require("./filters");
 const errors_1 = require("./errors");
 class ServiceBuilder {
     constructor(db, table, map) {
@@ -14,22 +14,18 @@ class ServiceBuilder {
     findOne(select) {
         return async (id) => {
             const result = await select.where((0, drizzle_orm_1.eq)(this.table.id, id));
-            if (result.length == 0) {
+            if (!result)
                 throw notFoundWithId(this.tableName, id);
-            }
-            return result[0];
+            return result;
         };
     }
     findAll(select) {
-        return async (options) => {
-            const { offset, limit } = (0, utils_1.getPagination)(options);
-            const conditions = (0, utils_1.getConditions)(options, this.map);
-            const items = select
-                .where((0, drizzle_orm_1.and)((0, drizzle_orm_1.isNull)(this.table.deletedAt), ...conditions))
-                .limit(limit)
-                .offset(offset)
-                .execute();
-            return items;
+        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() {
@@ -85,7 +81,7 @@ class ServiceBuilder {
             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, utils_1.buildWhere)(filters, this.map)));
+                .where((0, drizzle_orm_1.and)((0, drizzle_orm_1.isNull)(this.table.deletedAt), (0, filters_1.buildFilters)(this.map, filters)));
             return result.count;
         };
     }

package/dist/src/types.d.ts

@@ -1,27 +1,31 @@
 import { SQL } from "drizzle-orm";
-import { PgColumn, PgTable } from "drizzle-orm/pg-core";
-export interface CRUDService {
+import { AnyPgTable, PgColumn } from "drizzle-orm/pg-core";
+import z, { ZodObject } from "zod";
+export interface CRUDService<FSchema extends ZodObject> {
     findOne: (id: any) => Promise<any>;
-    findAll: (options: FindAllOptions<any>) => Promise<any>;
-    count: (filters: Filter<any>) => Promise<number>;
+    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 type PrimaryKeyData<TTable extends AnyPgTable> = {
+    [K in keyof TTable["_"]["columns"] as TTable["_"]["columns"][K] extends {
+        _: {
+            isPrimaryKey: true;
+        };
+    } ? K : never]: TTable["_"]["columns"][K]["_"]["data"];
+};
 export interface PaginationParams {
     page: number;
     pageSize: number;
 }
-export interface FindAllOptions<T extends PgTable> {
-    pagination?: PaginationParams;
-    filters?: Filter<T>;
-}
-export type Table = PgTable & {
+export type Table = AnyPgTable & {
     id: PgColumn;
     deletedAt: PgColumn;
 };
-export type PrimaryKeyType<T extends PgTable> = T["_"]["columns"]["id"]["_"]["data"];
-export type Filter<T extends PgTable> = Partial<T["$inferSelect"]>;
-export type FilterMap<T extends PgTable> = {
-    [K in keyof T["$inferSelect"]]?: (value: T["$inferSelect"][K]) => SQL;
+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;
 };
+export type Filter<Schema extends ZodObject> = z.infer<Schema>;

package/package.json

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

package/dist/src/utils.d.ts

@@ -1,9 +0,0 @@
-import { PgTable } from "drizzle-orm/pg-core";
-import { SQL } from "drizzle-orm";
-import { Filter, FilterMap, FindAllOptions } from "./types";
-export declare function buildWhere<T extends PgTable>(filters: Filter<T>, map: FilterMap<T>): SQL<unknown> | undefined;
-export declare function getPagination<T extends PgTable>(options?: FindAllOptions<T>): {
-    offset: number;
-    limit: number;
-};
-export declare function getConditions<T extends PgTable>(options: FindAllOptions<any> | undefined, map: FilterMap<T>): SQL<unknown>[];

package/dist/src/utils.js

@@ -1,41 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.buildWhere = buildWhere;
-exports.getPagination = getPagination;
-exports.getConditions = getConditions;
-const drizzle_orm_1 = require("drizzle-orm");
-function buildWhere(filters, map) {
-    const conditions = [];
-    // iteramos sólo sobre las claves de 'map'
-    for (const key of Object.keys(map)) {
-        const value = filters[key];
-        if (value !== undefined) {
-            // TS sabe que `value` es M[typeof key]
-            if (map[key]) {
-                conditions.push(map[key](value));
-            }
-        }
-    }
-    return conditions.length ? (0, drizzle_orm_1.and)(...conditions) : undefined;
-}
-function withPagination(qb, pagination) {
-    return qb.limit(pagination.pageSize).offset(pagination.page * pagination.pageSize);
-}
-function withFilters(table, qb, filters, map) {
-    return qb.where(buildWhere(filters, map));
-}
-function getPagination(options = {}) {
-    const page = options.pagination?.page || 1;
-    const limit = options.pagination?.pageSize || 10;
-    const offset = (page - 1) * limit;
-    return { offset, limit };
-}
-function getConditions(options = {}, map) {
-    const { filters } = options;
-    const conditions = [];
-    if (filters) {
-        const whereSql = buildWhere(filters, map);
-        conditions.push(whereSql);
-    }
-    return conditions;
-}