unconventional 0.0.3 → 0.0.4

package/dist/utils/db.utils.js

@@ -1,22 +1,26 @@
-import { AndOr, OneOrMany, SqlDirection } from "unconventional-pg-queries";
-import { NullSqlOperators, ValidSortDirections, ValidSqlOperators, andOrPattern } from "../types/db.types";
-import { RelationType } from "../types/decorator.types";
-import { parseExpandString, splitExpandUnit } from "./api.utils";
-import { equalArrays } from "./array.utils";
-import { APIError } from "../core/api-error";
-export function getExpand(model, expand) {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildFilter = exports.getConflict = exports.getReturn = exports.getPage = exports.getOrder = exports.getWhere = exports.getExpand = void 0;
+const unconventional_pg_queries_1 = require("unconventional-pg-queries");
+const db_types_1 = require("../types/db.types");
+const decorator_types_1 = require("../types/decorator.types");
+const api_utils_1 = require("./api.utils");
+const array_utils_1 = require("./array.utils");
+const api_error_1 = require("../core/api-error");
+/** Converts a stringified list of relational fields to an array of data needed to expand those fields in a SQL environment  */
+function getExpand(model, expand) {
     if (!expand)
         return {};
     const propSummary = model.schema.props;
     const expansions = {};
-    const parts = parseExpandString(expand);
+    const parts = (0, api_utils_1.parseExpandString)(expand);
     parts.forEach((field) => {
-        const { parent, children } = splitExpandUnit(field);
+        const { parent, children } = (0, api_utils_1.splitExpandUnit)(field);
         const relation = propSummary[parent]?.relation;
         if (!relation)
-            throw APIError.errInvalidQueryParameter(`Invalid expansion: ${parent}`);
+            throw api_error_1.APIError.errInvalidQueryParameter(`Invalid expansion: ${parent}`);
         expansions[parent] = {
-            type: [RelationType.HasOne, RelationType.BelongsTo].includes(relation.type) ? OneOrMany.One : OneOrMany.Many,
+            type: [decorator_types_1.RelationType.HasOne, decorator_types_1.RelationType.BelongsTo].includes(relation.type) ? unconventional_pg_queries_1.OneOrMany.One : unconventional_pg_queries_1.OneOrMany.Many,
             fromTable: model.collection,
             fromField: relation.from.toString(),
             toTable: relation.model.collection,
@@ -29,73 +33,84 @@ export function getExpand(model, expand) {
     });
     return expansions;
 }
-export function getWhere(model, filterString) {
+exports.getExpand = getExpand;
+/** Converts a string of filters to an array of 'where' clause outlines for a SQL environment */
+function getWhere(model, filterString) {
     if (!filterString)
         return [];
     const propSummary = model.schema.props;
     const wheres = [];
     if (filterString) {
-        filterString.split(andOrPattern).forEach((filter) => {
+        filterString.split(db_types_1.andOrPattern).forEach((filter) => {
+            // Handle logically combined clauses
             let andOr = undefined;
-            if (filter.startsWith(AndOr.And)) {
-                filter = filter.substring(AndOr.And.length + 1);
-                andOr = AndOr.And;
+            if (filter.startsWith(unconventional_pg_queries_1.AndOr.And)) {
+                filter = filter.substring(unconventional_pg_queries_1.AndOr.And.length + 1);
+                andOr = unconventional_pg_queries_1.AndOr.And;
             }
-            else if (filter.startsWith(AndOr.Or)) {
-                filter = filter.substring(AndOr.Or.length + 1);
-                andOr = AndOr.Or;
+            else if (filter.startsWith(unconventional_pg_queries_1.AndOr.Or)) {
+                filter = filter.substring(unconventional_pg_queries_1.AndOr.Or.length + 1);
+                andOr = unconventional_pg_queries_1.AndOr.Or;
             }
             let field = filter.substring(0, filter.indexOf(' '));
             let value = filter.substring(filter.lastIndexOf(' ') + 1);
             let operator = filter.substring(filter.indexOf(' ') + 1, filter.lastIndexOf(' '));
             let jsonPath = [];
+            // Handle IS NULL and IS NOT NULL, which don't have values
             if (operator.startsWith('IS')) {
                 operator = `${operator} ${value}`;
                 value = null;
             }
+            // Handle JSON path
             if (field.includes('.')) {
                 jsonPath = field.split('.');
                 field = jsonPath.shift();
             }
             if (!propSummary[field])
-                throw APIError.errInvalidQueryParameter(`Invalid filter: '${field}'`);
-            if (!ValidSqlOperators.includes(operator))
-                throw APIError.errInvalidQueryParameter(`Invalid operator in filter: '${operator}'`);
-            if (!value && !NullSqlOperators.includes(operator))
-                throw APIError.errInvalidQueryParameter(`Invalid value in filter: '${value}'`);
+                throw api_error_1.APIError.errInvalidQueryParameter(`Invalid filter: '${field}'`);
+            if (!db_types_1.ValidSqlOperators.includes(operator))
+                throw api_error_1.APIError.errInvalidQueryParameter(`Invalid operator in filter: '${operator}'`);
+            if (!value && !db_types_1.NullSqlOperators.includes(operator))
+                throw api_error_1.APIError.errInvalidQueryParameter(`Invalid value in filter: '${value}'`);
             wheres.push({ field, jsonPath, operator: operator, value, andOr });
         });
     }
     return wheres;
 }
-export function getOrder(model, sort) {
+exports.getWhere = getWhere;
+/** Converts a stringified list of fields to order ascending or descending to an array of order data for a SQL environment */
+function getOrder(model, sort) {
     if (!sort)
-        return [{ field: model.idField, direction: SqlDirection.Asc }];
+        return [{ field: model.idField, direction: unconventional_pg_queries_1.SqlDirection.Asc }];
     const propSummary = model.schema.props;
     const orders = [];
     sort.split(',').forEach((item) => {
         let [field, direction] = item.split(' ');
         let jsonPath = [];
-        direction ||= SqlDirection.Asc;
+        direction ||= unconventional_pg_queries_1.SqlDirection.Asc;
+        // Handle JSON path
         if (field.includes('.')) {
             jsonPath = field.split('.');
             field = jsonPath.shift();
         }
         if (!propSummary[field])
-            throw APIError.errInvalidQueryParameter(`Invalid orderBy field: '${field}'`);
-        if (!ValidSortDirections.includes(direction.toUpperCase()))
-            throw APIError.errInvalidQueryParameter(`Invalid orderBy direction: '${direction}'`);
+            throw api_error_1.APIError.errInvalidQueryParameter(`Invalid orderBy field: '${field}'`);
+        if (!db_types_1.ValidSortDirections.includes(direction.toUpperCase()))
+            throw api_error_1.APIError.errInvalidQueryParameter(`Invalid orderBy direction: '${direction}'`);
         orders.push({ field, jsonPath, direction: direction.toUpperCase() });
     });
     return orders;
 }
-export function getPage(model, cursor) {
+exports.getOrder = getOrder;
+function getPage(model, cursor) {
     if (!cursor)
         return undefined;
     const pagination = { field: model.idField, cursor };
     return pagination;
 }
-export function getReturn(model) {
+exports.getPage = getPage;
+/** Retrieves all non-relational fields from a model for the 'returning' clause of a SQL call */
+function getReturn(model) {
     const propSummary = model.schema.props;
     const fields = [];
     Object.entries(propSummary).forEach(([field, summary]) => {
@@ -104,24 +119,28 @@ export function getReturn(model) {
     });
     return fields;
 }
-export function getConflict(model, action, constraint) {
+exports.getReturn = getReturn;
+function getConflict(model, action, constraint) {
     if (!constraint)
         return undefined;
     const indexes = model.schema.indexes;
     for (const index of indexes) {
         const keys = Object.keys(index.definition);
-        if (equalArrays(keys, constraint))
+        if ((0, array_utils_1.equalArrays)(keys, constraint))
             return { action, constraint: keys };
     }
     return undefined;
 }
-export function buildFilter(field, operator, value) {
+exports.getConflict = getConflict;
+/** A type-safe way to build filter strings */
+function buildFilter(field, operator, value) {
     let formatted = `${value}`;
     if (typeof value === 'string')
         formatted = `'${value}'`;
     else if (Array.isArray(value))
         formatted = (typeof value[0] === 'string') ? `('${value.join("','")}')` : `(${value.join()})`;
-    else if (value == null || NullSqlOperators.includes(operator))
+    else if (value == null || db_types_1.NullSqlOperators.includes(operator))
         formatted = '';
     return `${field} ${operator} ${formatted}`;
 }
+exports.buildFilter = buildFilter;

package/dist/utils/function.utils.d.ts

@@ -6,5 +6,6 @@ interface CFFunctionDefinition {
     routeRegistrationFn: (server: BackendServer) => void;
 }
 export type CFFunctionHandler = (config: CFFunctionDefinition) => PagesFunction<{}>;
+/** A Cloudflare Pages function handler configured with routes, a database connection, middleware, cors, and error handling OOTB. */
 declare const functionHandler: CFFunctionHandler;
 export default functionHandler;

package/dist/utils/function.utils.js

@@ -1,6 +1,9 @@
-import { BackendServer } from "../server";
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const server_1 = require("../server");
+/** A Cloudflare Pages function handler configured with routes, a database connection, middleware, cors, and error handling OOTB. */
 const functionHandler = (config) => {
-    const server = new BackendServer();
+    const server = new server_1.BackendServer();
     let handler;
     return async (eventContext) => {
         if (!server.configured) {
@@ -11,4 +14,4 @@ const functionHandler = (config) => {
         return await handler(eventContext);
     };
 };
-export default functionHandler;
+exports.default = functionHandler;

package/dist/utils/index.js

@@ -1,8 +1,24 @@
-export * from './api.utils';
-export * from './array.utils';
-export * from './cache.utils';
-export * from './crypto.utils';
-export * from './db.utils';
-export * from './function.utils';
-export * from './middleware.utils';
-export * from './server.utils';
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./api.utils"), exports);
+__exportStar(require("./array.utils"), exports);
+__exportStar(require("./cache.utils"), exports);
+__exportStar(require("./crypto.utils"), exports);
+__exportStar(require("./db.utils"), exports);
+__exportStar(require("./function.utils"), exports);
+__exportStar(require("./middleware.utils"), exports);
+__exportStar(require("./server.utils"), exports);

package/dist/utils/middleware.utils.d.ts

@@ -1,3 +1,7 @@
 import { Input, MiddlewareHandler } from "hono";
 import { BaseHandler, Env } from "../types/api.types";
+/**
+ * Combines any number of RequestHandlers into one function that performs
+ * the logical OR of their results.
+ */
 export declare function Or<E extends Env = Env, P extends string = any, I extends Input = Input, T extends BaseHandler<E, P, I> | MiddlewareHandler<E, P, I> = MiddlewareHandler<E, P, I>>(...methods: Array<T>): MiddlewareHandler<E, P, I>;

package/dist/utils/middleware.utils.js

@@ -1,4 +1,11 @@
-export function Or(...methods) {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Or = void 0;
+/**
+ * Combines any number of RequestHandlers into one function that performs
+ * the logical OR of their results.
+ */
+function Or(...methods) {
     return async (ctx, next) => {
         const halt = async () => { };
         const promises = methods.map(x => x(ctx, halt));
@@ -8,3 +15,4 @@ export function Or(...methods) {
         await next();
     };
 }
+exports.Or = Or;

package/dist/utils/server.utils.d.ts

@@ -1,4 +1,7 @@
 import { DBFactory } from "../types";
+/** Default CORS middleware permitting all origins and methods */
 export declare const defaultCors: import("hono").MiddlewareHandler;
+/** Binds the database proxy to the BaseModel */
 export declare const bindDatabase: (getDB: DBFactory) => (ctx: any, next: any) => Promise<void>;
+/** Catches and formats errors in a standard way */
 export declare const defaultErrorHandler: (err: any, ctx: any) => any;

package/dist/utils/server.utils.js

@@ -1,19 +1,29 @@
-import { cors } from "hono/cors";
-import BaseModel from "../core/base.model";
-import { APIError } from "../core";
-export const defaultCors = cors({
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultErrorHandler = exports.bindDatabase = exports.defaultCors = void 0;
+const cors_1 = require("hono/cors");
+const base_model_1 = __importDefault(require("../core/base.model"));
+const core_1 = require("../core");
+/** Default CORS middleware permitting all origins and methods */
+exports.defaultCors = (0, cors_1.cors)({
     origin: "*",
     allowMethods: ["GET", "POST", "PUT", "PATCH", "DELETE", "OPTIONS"]
 });
-export const bindDatabase = (getDB) => {
+/** Binds the database proxy to the BaseModel */
+const bindDatabase = (getDB) => {
     return async (ctx, next) => {
-        if (!BaseModel.db)
-            BaseModel.db = getDB(ctx);
+        if (!base_model_1.default.db)
+            base_model_1.default.db = getDB(ctx);
         await next();
     };
 };
-export const defaultErrorHandler = (err, ctx) => {
-    if (err instanceof APIError) {
+exports.bindDatabase = bindDatabase;
+/** Catches and formats errors in a standard way */
+const defaultErrorHandler = (err, ctx) => {
+    if (err instanceof core_1.APIError) {
         ctx.status(err.statusCode || 500);
         return ctx.json({
             error_code: err.name,
@@ -25,3 +35,4 @@ export const defaultErrorHandler = (err, ctx) => {
     ctx.status(500);
     return ctx.json({ error: err.message });
 };
+exports.defaultErrorHandler = defaultErrorHandler;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "unconventional",
-  "version": "0.0.3",
+  "version": "0.0.4",
   "description": "A complete server built on Cloudflare Pages Functions",
   "keywords": [
     "cloudflare",