@promind/honey 1.34.5

package/dist/index.js

@@ -0,0 +1,997 @@
+var $3IFKa$sequelize = require("sequelize");
+var $3IFKa$path = require("path");
+var $3IFKa$dotenv = require("dotenv");
+var $3IFKa$cookieparser = require("cookie-parser");
+var $3IFKa$express = require("express");
+var $3IFKa$morgan = require("morgan");
+var $3IFKa$cors = require("cors");
+var $3IFKa$expressoasgenerator = require("express-oas-generator");
+var $3IFKa$knex = require("knex");
+
+
+function $parcel$exportWildcard(dest, source) {
+  Object.keys(source).forEach(function(key) {
+    if (key === 'default' || key === '__esModule' || Object.prototype.hasOwnProperty.call(dest, key)) {
+      return;
+    }
+
+    Object.defineProperty(dest, key, {
+      enumerable: true,
+      get: function get() {
+        return source[key];
+      }
+    });
+  });
+
+  return dest;
+}
+
+function $parcel$export(e, n, v, s) {
+  Object.defineProperty(e, n, {get: v, set: s, enumerable: true, configurable: true});
+}
+
+function $parcel$interopDefault(a) {
+  return a && a.__esModule ? a.default : a;
+}
+
+$parcel$export(module.exports, "createHoney", () => $c742f52b4af459bc$export$f375e35cdf499ccf);
+$parcel$export(module.exports, "defineModel", () => $c742f52b4af459bc$export$acd55aa037e791bb);
+$parcel$export(module.exports, "QueryTypes", () => $c742f52b4af459bc$export$9e0271c08bde0a49);
+$parcel$export(module.exports, "runDbQuery", () => $6eae9231903e3dbe$export$2e2bcd8739ae039);
+$parcel$export(module.exports, "createModel", () => $6eae9231903e3dbe$export$2f453c7f7b0d002b);
+$parcel$export(module.exports, "HttpError", () => $2a1659c6c3bea4d7$export$2e2bcd8739ae039);
+$parcel$export(module.exports, "handleHttpError", () => $2a1659c6c3bea4d7$export$cd2b46e1ebe8182d);
+$parcel$export(module.exports, "Honey", () => $e551a6691d3acd09$export$2e2bcd8739ae039);
+$parcel$export(module.exports, "validateRequestData", () => $e0429c84bb00f9a2$export$3b8deecb09f1ff23);
+
+
+
+
+function $7f54ec05d534b110$export$2e2bcd8739ae039(options) {
+    let uri = '';
+    if (typeof options === 'string') uri = options;
+    else uri = `postgres://${options.user}:${options.password}@${options.host}:${options.port}/${options.database}`;
+    const sequelize = new (0, $3IFKa$sequelize.Sequelize)(uri, {
+        logging: false
+    });
+    sequelize.authenticate().then(()=>{
+        console.log('DB Connection established successfully');
+    }).catch((err)=>{
+        console.log('DB Connection failed');
+        console.error(err);
+    });
+    return sequelize;
+}
+
+
+
+var $279104bade16c452$var$$parcel$__dirname = $3IFKa$path.resolve(__dirname, "../src/config");
+(0, ($parcel$interopDefault($3IFKa$dotenv))).config();
+(0, ($parcel$interopDefault($3IFKa$dotenv))).config({
+    path: (0, ($parcel$interopDefault($3IFKa$path))).join($279104bade16c452$var$$parcel$__dirname, '.env')
+});
+class $279104bade16c452$export$2e2bcd8739ae039 {
+    static{
+        this.getEnv = (key)=>{
+            return process.env[key];
+        };
+    }
+    constructor(options){
+        $279104bade16c452$export$2e2bcd8739ae039.db = (0, $7f54ec05d534b110$export$2e2bcd8739ae039)(options);
+    }
+    static get isLive() {
+        return process.env.NODE_ENV === 'production';
+    }
+    static defineModel(modelName, attributes, options) {
+        return this.db.define(modelName, attributes, options);
+    }
+}
+
+
+
+
+
+
+
+
+class $2a1659c6c3bea4d7$export$2e2bcd8739ae039 extends Error {
+    constructor(message, status){
+        super(message || 'Something went wrong'), this.status = status;
+    }
+}
+const $2a1659c6c3bea4d7$export$cd2b46e1ebe8182d = (err, res)=>{
+    return res.status(err.status || 500).send({
+        message: err.message || 'Something went wrong'
+    });
+};
+
+
+/**
+ * Event listener for HTTP server "error" event.
+ */ const $55ceba8bebac8f81$var$onError = (port)=>{
+    return (error)=>{
+        if (error.syscall !== 'listen') throw error;
+        const bind = typeof port === 'string' ? `Pipe ${port}` : `Port ${port}`;
+        // handle specific listen errors with friendly messages
+        switch(error.code){
+            case 'EACCES':
+                console.error(`${bind} requires elevated privileges`);
+                process.exit(1);
+            case 'EADDRINUSE':
+                console.error(`${bind} is already in use`);
+                process.exit(1);
+            default:
+                throw error;
+        }
+    };
+};
+/**
+ * Event listener for HTTP server "listening" event.
+ */ const $55ceba8bebac8f81$var$onListening = (server)=>{
+    return ()=>{
+        const addr = server.address();
+        const bind = typeof addr === 'string' ? `pipe ${addr}` : `port ${addr.port}`;
+        console.log(`%c Honey Server started on ${bind} `, 'background: #222; color: #bada55; font-size: 32px');
+    };
+};
+class $55ceba8bebac8f81$var$ExpressApp {
+    constructor(port, metadata){
+        this.metadata = metadata;
+        this.app = (0, ($parcel$interopDefault($3IFKa$express)))();
+        this.appRoutes = (0, ($parcel$interopDefault($3IFKa$express))).Router();
+        this.fallbackErrMessage = 'Endpoint does not exist';
+        this.routePrefix = '/api';
+        this.fallbackErrMessage = this.metadata?.fallbackErrorMessage || this.fallbackErrMessage;
+        this.routePrefix = this.metadata?.routePrefix || this.routePrefix;
+        this.initMiddlewares();
+        this.setupErrorFallback();
+        this.app.set('port', port);
+    }
+    listen() {
+        (0, ($parcel$interopDefault($3IFKa$expressoasgenerator))).handleRequests();
+        const port = Number(this.app.get('port'));
+        const server = this.app.listen(port);
+        server.on('error', $55ceba8bebac8f81$var$onError(port));
+        server.on('listening', $55ceba8bebac8f81$var$onListening(server));
+    }
+    initMiddlewares() {
+        const corsOptions = {
+            origin: '*',
+            methods: 'GET,HEAD,PUT,PATCH,POST,DELETE',
+            allowedHeaders: '*',
+            exposedHeaders: '*',
+            credentials: true,
+            optionsSuccessStatus: 204
+        };
+        (0, ($parcel$interopDefault($3IFKa$expressoasgenerator))).handleResponses(this.app, {});
+        this.app.use((0, ($parcel$interopDefault($3IFKa$morgan)))('dev'));
+        this.app.use((0, ($parcel$interopDefault($3IFKa$cors)))(corsOptions));
+        this.app.use((0, ($parcel$interopDefault($3IFKa$express))).json({
+            limit: '50mb',
+            verify (req, _res, buf) {
+                req.rawBody = buf;
+            }
+        }));
+        this.app.use((0, ($parcel$interopDefault($3IFKa$express))).urlencoded({
+            limit: '50mb',
+            extended: false
+        }));
+        this.app.use((0, ($parcel$interopDefault($3IFKa$cookieparser)))());
+        this.app.use(this.routePrefix, this.appRoutes);
+    }
+    setupErrorFallback() {
+        this.app.use((_, res)=>{
+            const err = new (0, $2a1659c6c3bea4d7$export$2e2bcd8739ae039)(this.fallbackErrMessage, 404);
+            return res.status(err.status).json({
+                message: err.message
+            });
+        });
+        // error handler
+        this.app.use((err, _, res)=>{
+            return res.status(err.status || 500).send({
+                message: 'Something went wrong'
+            });
+        });
+    }
+}
+var $55ceba8bebac8f81$export$2e2bcd8739ae039 = $55ceba8bebac8f81$var$ExpressApp;
+
+
+
+
+
+
+
+const $016b89c2f40cad11$var$formatters = {
+    string: String,
+    number: Number,
+    boolean: Boolean,
+    json: JSON.stringify,
+    object: JSON.stringify
+};
+const $016b89c2f40cad11$export$957212fbd899d523 = (body, params)=>{
+    const result = {};
+    Object.entries(params).forEach(([key, value])=>{
+        if (value === '@updatedAt') {
+            result[key] = new Date();
+            return;
+        }
+        if (!Object.keys(body).includes(key)) return;
+        const formatter = $016b89c2f40cad11$var$formatters[value];
+        result[key] = formatter && ![
+            null,
+            undefined
+        ].includes(body[key]) ? formatter(body[key]) : body[key];
+    });
+    return result;
+};
+const $016b89c2f40cad11$export$3fde508750f4a353 = (body, params)=>{
+    const result = Object.entries(params).reduce((acc, [key, value])=>{
+        if (!Object.keys(body).includes(key) && value !== '@updatedAt') return {
+            ...acc
+        };
+        let formattedValue;
+        if (value === '@updatedAt') formattedValue = new Date();
+        else formattedValue = ![
+            null,
+            undefined
+        ].includes(body[key]) ? $016b89c2f40cad11$var$formatters[typeof body[key]](body[key]) : body[key];
+        return {
+            ...acc,
+            [key]: {
+                value: formattedValue,
+                operator: value === '@updatedAt' ? 'replace' : value
+            }
+        };
+    }, {});
+    return result;
+};
+const $016b89c2f40cad11$export$390602d0ccf68ce6 = (queryParams, filter)=>{
+    const result = {};
+    Object.entries(filter).forEach(([key, param])=>{
+        if (key === '$or') {
+            const val = $016b89c2f40cad11$export$390602d0ccf68ce6(queryParams, param);
+            // skip missing query params
+            if (!Object.keys(val).length) return;
+            result[key] = val;
+        } else {
+            // skip missing query params
+            if (!Object.keys(queryParams).includes(key) && param.overrideValue === undefined) return;
+            const valueFormatter = $016b89c2f40cad11$var$formatters[param.value];
+            if (!valueFormatter) throw new (0, $2a1659c6c3bea4d7$export$2e2bcd8739ae039)('Invalid filter value type', 500);
+            const valueToUse = param.overrideValue !== undefined ? param.overrideValue : queryParams[key];
+            result[key] = {
+                operator: param.operator,
+                value: valueFormatter(valueToUse)
+            };
+        }
+    });
+    return result;
+};
+
+
+function $e6033bad46ade8f8$export$2e2bcd8739ae039({ db: db, resource: resource, params: params, message: message, processResponseData: processResponseData, processErrorResponse: processErrorResponse }) {
+    return async (req, res, next)=>{
+        try {
+            const body = (0, $016b89c2f40cad11$export$957212fbd899d523)(req.body, params);
+            const data = await db.create(resource, body);
+            const id = data[0].id;
+            res.send({
+                message: message,
+                data: req.body.dataOverride || (processResponseData ? await processResponseData({
+                    id: id
+                }, req) : {
+                    id: id
+                })
+            });
+            next({
+                message: message,
+                data: {
+                    id: id
+                }
+            });
+        } catch (error) {
+            if (processErrorResponse) error = processErrorResponse(error);
+            (0, $2a1659c6c3bea4d7$export$cd2b46e1ebe8182d)(error, res);
+            next({
+                ...error,
+                isError: true
+            });
+        }
+    };
+}
+
+
+
+
+function $b1328f4a111bb650$export$7b6dde2038c44e91({ db: db, resource: resource, fields: fields, idField: idField = 'id', processResponseData: processResponseData, processErrorResponse: processErrorResponse, filterQuery: filterQuery = {} }) {
+    return async (req, res, next)=>{
+        try {
+            const id = req.params.id;
+            const filter = filterQuery && (0, $016b89c2f40cad11$export$390602d0ccf68ce6)(req.query, filterQuery);
+            const data = await db.read(resource, fields, {
+                [idField]: {
+                    value: id,
+                    operator: '='
+                },
+                ...filter
+            });
+            if (!data?.length) throw new (0, $2a1659c6c3bea4d7$export$2e2bcd8739ae039)('Record does not exist', 404);
+            res.send({
+                data: processResponseData ? await processResponseData(data[0], req) : data[0]
+            });
+            next({
+                data: data
+            });
+        } catch (error) {
+            if (processErrorResponse) error = processErrorResponse(error);
+            (0, $2a1659c6c3bea4d7$export$cd2b46e1ebe8182d)(error, res);
+            next({
+                ...error,
+                isError: true
+            });
+        }
+    };
+}
+function $b1328f4a111bb650$export$7b48d281d65870ad({ db: db, resource: resource, fields: fields, filterQuery: filterQuery, format: format, processResponseData: processResponseData, processErrorResponse: processErrorResponse }) {
+    return async (req, res, next)=>{
+        try {
+            const page = Number(req.query.page);
+            const limit = Number(req.query.limit);
+            const paginate = limit || page ? {
+                page: page || 1,
+                limit: limit || 10
+            } : undefined;
+            const filter = filterQuery && (0, $016b89c2f40cad11$export$390602d0ccf68ce6)(req.query, filterQuery);
+            let data = await db.read(resource, fields, filter, paginate, format);
+            let total = 0;
+            if (paginate) {
+                total = Number(data[0]?.['honey_total_count'] || 0);
+                data = data.map((item)=>{
+                    delete item['honey_total_count'];
+                    return item;
+                });
+            }
+            if (processResponseData) data = await processResponseData(data, req);
+            else if (!data?.length) throw new (0, $2a1659c6c3bea4d7$export$2e2bcd8739ae039)('No records found', 404);
+            const response = {
+                data: data,
+                meta: {
+                    ...!!paginate && {
+                        pagination: {
+                            total: total,
+                            pageSize: limit,
+                            page: page,
+                            pageCount: Math.ceil(total / limit)
+                        }
+                    }
+                }
+            };
+            res.send(response);
+            next(response);
+        } catch (error) {
+            if (processErrorResponse) error = processErrorResponse(error);
+            (0, $2a1659c6c3bea4d7$export$cd2b46e1ebe8182d)(error, res);
+            next({
+                ...error,
+                isError: true
+            });
+        }
+    };
+}
+
+
+
+
+function $1d3f139d2d29337d$export$94bae363557b314a({ db: db, resource: resource, params: params, message: message, idField: idField = 'id', processErrorResponse: processErrorResponse, filterQuery: filterQuery = {} }) {
+    return async (req, res, next)=>{
+        try {
+            const body = (0, $016b89c2f40cad11$export$3fde508750f4a353)(req.body, params);
+            const additionalFilter = filterQuery && (0, $016b89c2f40cad11$export$390602d0ccf68ce6)(req.body, filterQuery);
+            const filter = {
+                [idField]: {
+                    operator: '=',
+                    value: req.params.id
+                },
+                ...additionalFilter
+            };
+            await db.update(resource, body, filter);
+            res.send({
+                message: message
+            });
+            next({
+                message: message
+            });
+        } catch (error) {
+            if (processErrorResponse) error = processErrorResponse(error);
+            (0, $2a1659c6c3bea4d7$export$cd2b46e1ebe8182d)(error, res);
+            next({
+                ...error,
+                isError: true
+            });
+        }
+    };
+}
+function $1d3f139d2d29337d$export$805408382b623838({ db: db, resource: resource, params: params, message: message, filterQuery: filterQuery, processErrorResponse: processErrorResponse }) {
+    return async (req, res, next)=>{
+        try {
+            const body = (0, $016b89c2f40cad11$export$3fde508750f4a353)(req.body, params);
+            const filter = filterQuery && (0, $016b89c2f40cad11$export$390602d0ccf68ce6)(req.body, filterQuery);
+            await db.update(resource, body, filter);
+            res.send({
+                message: message
+            });
+            next({
+                message: message
+            });
+        } catch (error) {
+            if (processErrorResponse) error = processErrorResponse(error);
+            (0, $2a1659c6c3bea4d7$export$cd2b46e1ebe8182d)(error, res);
+            next({
+                ...error,
+                isError: true
+            });
+        }
+    };
+}
+
+
+
+
+function $389a0330ed47be73$export$d5a9f256d3442907({ db: db, resource: resource, params: params, message: message, idField: idField = 'id', processErrorResponse: processErrorResponse }) {
+    return async (req, res, next)=>{
+        try {
+            req.body[idField] = req.params.id;
+            params = {
+                ...params,
+                [idField]: 'replace'
+            };
+            const body = (0, $016b89c2f40cad11$export$3fde508750f4a353)(req.body, params);
+            await db.upsert(resource, body, [
+                idField
+            ]);
+            res.send({
+                message: message
+            });
+            next({
+                message: message
+            });
+        } catch (error) {
+            if (processErrorResponse) error = processErrorResponse(error);
+            (0, $2a1659c6c3bea4d7$export$cd2b46e1ebe8182d)(error, res);
+            next({
+                ...error,
+                isError: true
+            });
+        }
+    };
+}
+function $389a0330ed47be73$export$e94809b3c2751b8b({ db: db, resource: resource, params: params, message: message, conflictTarget: conflictTarget, processErrorResponse: processErrorResponse }) {
+    return async (req, res, next)=>{
+        try {
+            const body = (0, $016b89c2f40cad11$export$3fde508750f4a353)(req.body, params);
+            await db.upsert(resource, body, conflictTarget);
+            res.send({
+                message: message
+            });
+            next({
+                message: message
+            });
+        } catch (error) {
+            if (processErrorResponse) error = processErrorResponse(error);
+            (0, $2a1659c6c3bea4d7$export$cd2b46e1ebe8182d)(error, res);
+            next({
+                ...error,
+                isError: true
+            });
+        }
+    };
+}
+
+
+
+
+function $877c51bd1d8c8e63$export$18d25c756727a4e9({ db: db, resource: resource, message: message, idField: idField = 'id', processErrorResponse: processErrorResponse, filterQuery: filterQuery = {} }) {
+    return async (req, res, next)=>{
+        try {
+            const id = req.params[idField || 'id'];
+            const filter = filterQuery && (0, $016b89c2f40cad11$export$390602d0ccf68ce6)(req.body, filterQuery);
+            await db.delete(resource, {
+                [idField]: {
+                    value: id,
+                    operator: '='
+                },
+                ...filter
+            });
+            res.send({
+                message: message
+            });
+            next({
+                message: message
+            });
+        } catch (error) {
+            if (processErrorResponse) error = processErrorResponse(error);
+            (0, $2a1659c6c3bea4d7$export$cd2b46e1ebe8182d)(error, res);
+            next({
+                ...error,
+                isError: true
+            });
+        }
+    };
+}
+
+
+
+
+
+
+// eslint-disable-next-line
+const $e551a6691d3acd09$var$defaultExitMiddleware = (data, req, res, next)=>{
+    if (process.env.NODE_ENV !== 'production') console.log('Response:', data);
+};
+class $e551a6691d3acd09$export$2e2bcd8739ae039 {
+    constructor(express, postgres){
+        this.express = express;
+        this.postgres = postgres;
+    }
+    get routes() {
+        return this.express.appRoutes;
+    }
+    get db() {
+        return (0, $279104bade16c452$export$2e2bcd8739ae039).db;
+    }
+    crud({ method: method, path: path, controller: controller, middleware: middleware = [], exitMiddleware: exitMiddleware = [
+        $e551a6691d3acd09$var$defaultExitMiddleware
+    ] }) {
+        const dbCheck = async (req, res, next)=>{
+            if (!(0, $279104bade16c452$export$2e2bcd8739ae039).db) return res.status(503).send({
+                message: 'DB Initialization in progress'
+            });
+            else next();
+        };
+        this.express.appRoutes[method](path, dbCheck, ...middleware, controller, ...exitMiddleware);
+    }
+    addMiddleware(middleware) {
+        this.express.appRoutes.use(...middleware);
+    }
+    startServer() {
+        this.express.listen();
+    }
+    create({ resource: resource, params: params, message: message, middleware: middleware, pathOverride: pathOverride, exitMiddleware: exitMiddleware, processResponseData: processResponseData, processErrorResponse: processErrorResponse, table: table }) {
+        const path = pathOverride || `/${resource}`;
+        resource = table || resource;
+        const controller = (0, $e6033bad46ade8f8$export$2e2bcd8739ae039)({
+            db: this.postgres,
+            resource: resource,
+            params: params,
+            message: message,
+            processResponseData: processResponseData,
+            processErrorResponse: processErrorResponse
+        });
+        this.crud({
+            method: 'post',
+            path: path,
+            controller: controller,
+            middleware: middleware,
+            exitMiddleware: exitMiddleware
+        });
+    }
+    get({ resource: resource, fields: fields, filter: filter, format: format, middleware: middleware, pathOverride: pathOverride, exitMiddleware: exitMiddleware, processResponseData: processResponseData, processErrorResponse: processErrorResponse, table: table }) {
+        const path = pathOverride || `/${resource}`;
+        resource = table || resource;
+        const controller = (0, $b1328f4a111bb650$export$7b48d281d65870ad)({
+            db: this.postgres,
+            resource: resource,
+            fields: fields,
+            filterQuery: filter,
+            format: format,
+            processResponseData: processResponseData,
+            processErrorResponse: processErrorResponse
+        });
+        this.crud({
+            method: 'get',
+            path: path,
+            controller: controller,
+            middleware: middleware,
+            exitMiddleware: exitMiddleware
+        });
+    }
+    getById({ resource: resource, fields: fields, idField: idField, middleware: middleware, pathOverride: pathOverride, exitMiddleware: exitMiddleware, processResponseData: processResponseData, processErrorResponse: processErrorResponse, table: table, filter: filter }) {
+        const path = pathOverride || `/${resource}/:id`;
+        resource = table || resource;
+        const controller = (0, $b1328f4a111bb650$export$7b6dde2038c44e91)({
+            db: this.postgres,
+            resource: resource,
+            fields: fields,
+            idField: idField || 'id',
+            processResponseData: processResponseData,
+            processErrorResponse: processErrorResponse,
+            filterQuery: filter
+        });
+        this.crud({
+            method: 'get',
+            path: path,
+            controller: controller,
+            middleware: middleware,
+            exitMiddleware: exitMiddleware
+        });
+    }
+    updateById({ resource: resource, params: params, idField: idField, message: message, middleware: middleware, pathOverride: pathOverride, exitMiddleware: exitMiddleware, table: table, filter: filter }) {
+        const path = pathOverride || `/${resource}/:id`;
+        resource = table || resource;
+        const controller = (0, $1d3f139d2d29337d$export$94bae363557b314a)({
+            db: this.postgres,
+            resource: resource,
+            params: params,
+            message: message,
+            idField: idField,
+            filterQuery: filter
+        });
+        this.crud({
+            method: 'put',
+            path: path,
+            controller: controller,
+            middleware: middleware,
+            exitMiddleware: exitMiddleware
+        });
+    }
+    update({ resource: resource, params: params, filter: filter, message: message, middleware: middleware, pathOverride: pathOverride, exitMiddleware: exitMiddleware, table: table }) {
+        const path = pathOverride || `/${resource}`;
+        resource = table || resource;
+        const controller = (0, $1d3f139d2d29337d$export$805408382b623838)({
+            db: this.postgres,
+            resource: resource,
+            params: params,
+            message: message,
+            filterQuery: filter
+        });
+        this.crud({
+            method: 'put',
+            path: path,
+            controller: controller,
+            middleware: middleware,
+            exitMiddleware: exitMiddleware
+        });
+    }
+    upsertById({ resource: resource, params: params, idField: idField, message: message, middleware: middleware, pathOverride: pathOverride, exitMiddleware: exitMiddleware, table: table }) {
+        const path = pathOverride || `/${resource}/:id/upsert`;
+        resource = table || resource;
+        const controller = (0, $389a0330ed47be73$export$d5a9f256d3442907)({
+            db: this.postgres,
+            resource: resource,
+            params: params,
+            message: message,
+            idField: idField
+        });
+        this.crud({
+            method: 'put',
+            path: path,
+            controller: controller,
+            middleware: middleware,
+            exitMiddleware: exitMiddleware
+        });
+    }
+    upsert({ resource: resource, params: params, message: message, middleware: middleware, pathOverride: pathOverride, exitMiddleware: exitMiddleware, conflictTarget: conflictTarget, table: table }) {
+        const path = pathOverride || `/${resource}/:id/upsert`;
+        resource = table || resource;
+        const controller = (0, $389a0330ed47be73$export$e94809b3c2751b8b)({
+            db: this.postgres,
+            resource: resource,
+            params: params,
+            message: message,
+            conflictTarget: conflictTarget
+        });
+        this.crud({
+            method: 'put',
+            path: path,
+            controller: controller,
+            middleware: middleware,
+            exitMiddleware: exitMiddleware
+        });
+    }
+    deleteById({ resource: resource, message: message, middleware: middleware, pathOverride: pathOverride, exitMiddleware: exitMiddleware, idField: idField, filter: filter, table: table }) {
+        const path = pathOverride || `/${resource}/:id`;
+        resource = table || resource;
+        const controller = (0, $877c51bd1d8c8e63$export$18d25c756727a4e9)({
+            db: this.postgres,
+            resource: resource,
+            message: message,
+            idField: idField,
+            filterQuery: filter
+        });
+        this.crud({
+            method: 'delete',
+            path: path,
+            controller: controller,
+            middleware: middleware,
+            exitMiddleware: exitMiddleware
+        });
+    }
+}
+
+
+
+
+
+class $eb35754384d9f185$export$d8ee7b97a871dca3 {
+    static{
+        this.instances = new Map();
+    }
+    static getInstance(identifier, initFn) {
+        if (!this.instances.has(identifier) && initFn) this.instances.set(identifier, initFn());
+        return this.instances.get(identifier);
+    }
+}
+function $eb35754384d9f185$export$2e2bcd8739ae039(identifier, initFn) {
+    return $eb35754384d9f185$export$d8ee7b97a871dca3.getInstance(identifier, initFn);
+}
+
+
+function $6eae9231903e3dbe$export$2e2bcd8739ae039(query, params) {
+    const { replacements: replacements, type: type } = params || {};
+    return (0, $279104bade16c452$export$2e2bcd8739ae039).db.query(query, {
+        raw: true,
+        replacements: replacements,
+        type: type
+    });
+}
+class $6eae9231903e3dbe$var$ModelCreator {
+    static{
+        this.model = {};
+    }
+    static createModel(modelName, attributes, options) {
+        if (!this.model[modelName]) this.model[modelName] = (0, $279104bade16c452$export$2e2bcd8739ae039).db.define(modelName, attributes, options);
+        return this.model[modelName];
+    }
+}
+function $6eae9231903e3dbe$export$2f453c7f7b0d002b(modelName, attributes, options) {
+    return $6eae9231903e3dbe$var$ModelCreator.createModel.bind($6eae9231903e3dbe$var$ModelCreator)(modelName, attributes, options);
+}
+const $6eae9231903e3dbe$export$a858f29c02f648c6 = ()=>(0, $eb35754384d9f185$export$2e2bcd8739ae039)('knex', ()=>{
+        return (0, ($parcel$interopDefault($3IFKa$knex)))({
+            client: 'pg'
+        });
+    });
+
+
+const $6fe5fb6fcb62dbab$export$1b001418845b471c = (query, filter = {})=>{
+    Object.entries(filter).forEach(([field, data])=>{
+        if (field === '$or') query.where((builder)=>{
+            Object.entries(data).forEach(([orField, orData], index)=>{
+                const method = index === 0 ? 'where' : 'orWhere';
+                const orParam = orData;
+                if ([
+                    'like',
+                    'not like'
+                ].includes(orParam.operator)) builder[method](orField, 'ilike', `%${orParam.value}%`);
+                else builder[method](orField, orParam.operator, orParam.value);
+            });
+        });
+        else {
+            const param = data;
+            if ([
+                'like',
+                'not like'
+            ].includes(param.operator)) query.where(field, param.operator === 'like' ? 'ilike' : 'not ilike', `%${param.value}%`);
+            else query.where(field, param.operator, param.value);
+        }
+    });
+    return query;
+};
+const $6fe5fb6fcb62dbab$export$53b231d60a00019b = (table, data)=>{
+    const knex = (0, $6eae9231903e3dbe$export$a858f29c02f648c6)();
+    const { sql: query, bindings: replacements } = knex(table).insert(data).returning('id').toSQL();
+    return {
+        query: query,
+        replacements: replacements
+    };
+};
+const $6fe5fb6fcb62dbab$export$60d67f341ad4c4 = (table, fields, filter, paginate, format)=>{
+    const knex = (0, $6eae9231903e3dbe$export$a858f29c02f648c6)();
+    let q = knex(table).select(fields);
+    // Add total count if pagination is needed
+    if (paginate) // Using knex.raw to create the count column with the same name as in original code
+    q = knex(table).select([
+        ...fields.map((field)=>knex.raw(`?? as ??`, [
+                field,
+                field
+            ])),
+        knex.raw('count(??) OVER() AS honey_total_count', [
+            fields[0]
+        ])
+    ]);
+    // Apply filters
+    if (filter) q = $6fe5fb6fcb62dbab$export$1b001418845b471c(q, filter);
+    // Apply sorting
+    if (format?.sort && format.sortField) q.orderBy(format.sortField, format.sort);
+    // Apply pagination
+    if (paginate) q.limit(paginate.limit).offset(paginate.limit * (paginate.page - 1));
+    const { sql: query, bindings: replacements } = q.toSQL();
+    return {
+        query: query,
+        replacements: replacements
+    };
+};
+const $6fe5fb6fcb62dbab$export$9234fcbc1f0d2048 = (table, data, filter)=>{
+    const knex = (0, $6eae9231903e3dbe$export$a858f29c02f648c6)();
+    let q = knex(table);
+    // Build the update object
+    const updateData = {};
+    Object.entries(data).forEach(([field, fieldData])=>{
+        const param = fieldData;
+        if (param.operator === 'inc') updateData[field] = knex.raw('?? + ?', [
+            field,
+            param.value
+        ]);
+        else if (param.operator === 'dec') updateData[field] = knex.raw('?? - ?', [
+            field,
+            param.value
+        ]);
+        else updateData[field] = param.value;
+    });
+    // Apply filter conditions
+    if (filter) q = $6fe5fb6fcb62dbab$export$1b001418845b471c(q, filter);
+    const { sql: query, bindings: replacements } = q.update(updateData).toSQL();
+    console.log(query, replacements);
+    return {
+        query: query,
+        replacements: replacements
+    };
+};
+const $6fe5fb6fcb62dbab$export$3303c43960743687 = (table, filter)=>{
+    const knex = (0, $6eae9231903e3dbe$export$a858f29c02f648c6)();
+    let q = knex(table);
+    if (filter) q = $6fe5fb6fcb62dbab$export$1b001418845b471c(q, filter);
+    const { sql: query, bindings: replacements } = q.delete().toSQL();
+    return {
+        query: query,
+        replacements: replacements
+    };
+};
+const $6fe5fb6fcb62dbab$export$65b914f34962db1e = (table, data, conflictTarget)=>{
+    const knex = (0, $6eae9231903e3dbe$export$a858f29c02f648c6)();
+    // Prepare insert data
+    const insertData = {};
+    Object.entries(data).forEach(([field, fieldData])=>{
+        insertData[field] = fieldData.value;
+    });
+    // Prepare update data for conflict resolution
+    const updateData = {};
+    Object.entries(data).forEach(([field, fieldData])=>{
+        const param = fieldData;
+        if (param.operator === 'inc') updateData[field] = knex.raw('?? + ?', [
+            `${table}.${field}`,
+            param.value
+        ]);
+        else if (param.operator === 'dec') updateData[field] = knex.raw('?? - ?', [
+            `${table}.${field}`,
+            param.value
+        ]);
+        else updateData[field] = param.value;
+    });
+    const { sql: query, bindings: replacements } = knex(table).insert(insertData).onConflict(conflictTarget).merge(updateData).toSQL();
+    return {
+        query: query,
+        replacements: replacements
+    };
+};
+
+
+
+class $43b99269306b3d62$export$2e2bcd8739ae039 {
+    async read(table, fields, filter, paginate, format) {
+        const { query: query, replacements: replacements } = (0, $6fe5fb6fcb62dbab$export$60d67f341ad4c4)(table, fields, filter, paginate, format);
+        const result = await (0, $279104bade16c452$export$2e2bcd8739ae039).db.query(query, {
+            type: (0, $3IFKa$sequelize.QueryTypes).SELECT,
+            raw: true,
+            replacements: [
+                ...replacements
+            ]
+        });
+        return result;
+    }
+    async create(table, data) {
+        const { query: query, replacements: replacements } = (0, $6fe5fb6fcb62dbab$export$53b231d60a00019b)(table, data);
+        const res = await (0, $279104bade16c452$export$2e2bcd8739ae039).db.query(query, {
+            type: (0, $3IFKa$sequelize.QueryTypes).INSERT,
+            raw: true,
+            replacements: [
+                ...replacements
+            ]
+        });
+        // inserted ids
+        return res[0];
+    }
+    async update(table, data, filter) {
+        const { query: query, replacements: replacements } = (0, $6fe5fb6fcb62dbab$export$9234fcbc1f0d2048)(table, data, filter);
+        await (0, $279104bade16c452$export$2e2bcd8739ae039).db.query(query, {
+            type: (0, $3IFKa$sequelize.QueryTypes).UPDATE,
+            raw: true,
+            replacements: [
+                ...replacements
+            ]
+        });
+    }
+    async delete(table, filter) {
+        const { query: query, replacements: replacements } = (0, $6fe5fb6fcb62dbab$export$3303c43960743687)(table, filter);
+        await (0, $279104bade16c452$export$2e2bcd8739ae039).db.query(query, {
+            type: (0, $3IFKa$sequelize.QueryTypes).DELETE,
+            raw: true,
+            replacements: [
+                ...replacements
+            ]
+        });
+    }
+    async upsert(table, data, conflictTarget) {
+        const { query: query, replacements: replacements } = (0, $6fe5fb6fcb62dbab$export$65b914f34962db1e)(table, data, conflictTarget);
+        await (0, $279104bade16c452$export$2e2bcd8739ae039).db.query(query, {
+            type: (0, $3IFKa$sequelize.QueryTypes).INSERT,
+            raw: true,
+            replacements: [
+                ...replacements
+            ]
+        });
+    }
+}
+
+
+function $e3f949bd939b0c31$export$21d1ad8451a259af(val) {
+    const port = parseInt(val, 10);
+    if (isNaN(port)) // named pipe
+    return val;
+    if (port >= 0) // port number
+    return port;
+    throw new Error('Invalid port number');
+}
+
+
+
+
+
+const $e0429c84bb00f9a2$export$3b8deecb09f1ff23 = (schema, location = 'body', options = {
+    allowUnknown: true
+})=>async (req, res, next)=>{
+        try {
+            const validationResult = schema.validate(req[location], options);
+            const validationError = validationResult.error?.message;
+            if (validationError) throw new (0, $2a1659c6c3bea4d7$export$2e2bcd8739ae039)(validationError, 422);
+            return next();
+        } catch (error) {
+            (0, $2a1659c6c3bea4d7$export$cd2b46e1ebe8182d)(error, res);
+        }
+    };
+var $e0429c84bb00f9a2$export$2e2bcd8739ae039 = $e0429c84bb00f9a2$export$3b8deecb09f1ff23;
+
+
+process.on('SIGINT', ()=>{
+    // process reload ongoing
+    // close connections, clear cache, etc
+    // by default, you have 1600ms
+    process.exit(0);
+});
+function $c742f52b4af459bc$export$f375e35cdf499ccf(port, dbOptions, metadata) {
+    new (0, $279104bade16c452$export$2e2bcd8739ae039)(dbOptions);
+    const portVal = (0, $e3f949bd939b0c31$export$21d1ad8451a259af)(port || process.env.PORT || '3000');
+    const express = new (0, $55ceba8bebac8f81$export$2e2bcd8739ae039)(portVal, metadata);
+    const postgres = new (0, $43b99269306b3d62$export$2e2bcd8739ae039)();
+    const honey = new (0, $e551a6691d3acd09$export$2e2bcd8739ae039)(express, postgres);
+    return honey;
+}
+const $c742f52b4af459bc$export$acd55aa037e791bb = (0, $279104bade16c452$export$2e2bcd8739ae039).defineModel.bind((0, $279104bade16c452$export$2e2bcd8739ae039));
+function $c742f52b4af459bc$var$getQueryTypes() {
+    const { SELECT: SELECT, INSERT: INSERT, UPDATE: UPDATE, DELETE: DELETE, RAW: RAW, UPSERT: UPSERT } = (0, $3IFKa$sequelize.QueryTypes);
+    const exposedTypes = {
+        SELECT: SELECT,
+        INSERT: INSERT,
+        UPDATE: UPDATE,
+        DELETE: DELETE,
+        RAW: RAW,
+        UPSERT: UPSERT
+    };
+    return exposedTypes;
+}
+const $c742f52b4af459bc$export$9e0271c08bde0a49 = $c742f52b4af459bc$var$getQueryTypes();
+$parcel$exportWildcard(module.exports, $3IFKa$sequelize);
+
+
+//# sourceMappingURL=index.js.map