unconventional 0.0.1 → 0.0.3

package/dist/utils/db.utils.d.ts

@@ -0,0 +1,9 @@
+import { ConflictResolution, Expansion, SqlConflict, SqlOrder, SqlPaginate, SqlWhere, SqlWhereOperator } from "unconventional-pg-queries";
+import BaseModel from "../core/base.model";
+export declare function getExpand<T extends typeof BaseModel>(model: T, expand?: string): Record<string, Expansion>;
+export declare function getWhere<T extends typeof BaseModel>(model: T, filterString?: string): SqlWhere[];
+export declare function getOrder<T extends typeof BaseModel>(model: T, sort?: string): SqlOrder[];
+export declare function getPage<T extends typeof BaseModel>(model: T, cursor?: string | number): SqlPaginate | undefined;
+export declare function getReturn<T extends typeof BaseModel>(model: T): string[];
+export declare function getConflict<T extends typeof BaseModel>(model: T, action: ConflictResolution, constraint?: Array<keyof InstanceType<T>>): SqlConflict | undefined;
+export declare function buildFilter<T>(field: keyof T, operator: SqlWhereOperator, value?: any): string;

package/dist/utils/db.utils.js

@@ -0,0 +1,127 @@
+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) {
+    if (!expand)
+        return {};
+    const propSummary = model.schema.props;
+    const expansions = {};
+    const parts = parseExpandString(expand);
+    parts.forEach((field) => {
+        const { parent, children } = splitExpandUnit(field);
+        const relation = propSummary[parent]?.relation;
+        if (!relation)
+            throw APIError.errInvalidQueryParameter(`Invalid expansion: ${parent}`);
+        expansions[parent] = {
+            type: [RelationType.HasOne, RelationType.BelongsTo].includes(relation.type) ? OneOrMany.One : OneOrMany.Many,
+            fromTable: model.collection,
+            fromField: relation.from.toString(),
+            toTable: relation.model.collection,
+            toField: relation.to.toString(),
+            throughTable: relation.through?.model.collection,
+            throughFromField: relation.through?.from.toString(),
+            throughToField: relation.through?.to.toString(),
+            expand: children ? getExpand(relation.model, children) : undefined
+        };
+    });
+    return expansions;
+}
+export function getWhere(model, filterString) {
+    if (!filterString)
+        return [];
+    const propSummary = model.schema.props;
+    const wheres = [];
+    if (filterString) {
+        filterString.split(andOrPattern).forEach((filter) => {
+            let andOr = undefined;
+            if (filter.startsWith(AndOr.And)) {
+                filter = filter.substring(AndOr.And.length + 1);
+                andOr = AndOr.And;
+            }
+            else if (filter.startsWith(AndOr.Or)) {
+                filter = filter.substring(AndOr.Or.length + 1);
+                andOr = 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 = [];
+            if (operator.startsWith('IS')) {
+                operator = `${operator} ${value}`;
+                value = null;
+            }
+            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}'`);
+            wheres.push({ field, jsonPath, operator: operator, value, andOr });
+        });
+    }
+    return wheres;
+}
+export function getOrder(model, sort) {
+    if (!sort)
+        return [{ field: model.idField, direction: SqlDirection.Asc }];
+    const propSummary = model.schema.props;
+    const orders = [];
+    sort.split(',').forEach((item) => {
+        let [field, direction] = item.split(' ');
+        let jsonPath = [];
+        direction ||= SqlDirection.Asc;
+        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}'`);
+        orders.push({ field, jsonPath, direction: direction.toUpperCase() });
+    });
+    return orders;
+}
+export function getPage(model, cursor) {
+    if (!cursor)
+        return undefined;
+    const pagination = { field: model.idField, cursor };
+    return pagination;
+}
+export function getReturn(model) {
+    const propSummary = model.schema.props;
+    const fields = [];
+    Object.entries(propSummary).forEach(([field, summary]) => {
+        if (!summary.relation)
+            fields.push(field);
+    });
+    return fields;
+}
+export 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))
+            return { action, constraint: keys };
+    }
+    return undefined;
+}
+export 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))
+        formatted = '';
+    return `${field} ${operator} ${formatted}`;
+}

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

@@ -0,0 +1,10 @@
+/// <reference types="@cloudflare/workers-types" />
+import { BackendServer } from "../server";
+import { ServerConfig } from "../types";
+interface CFFunctionDefinition {
+    serverConfig: ServerConfig;
+    routeRegistrationFn: (server: BackendServer) => void;
+}
+export type CFFunctionHandler = (config: CFFunctionDefinition) => PagesFunction<{}>;
+declare const functionHandler: CFFunctionHandler;
+export default functionHandler;

package/dist/utils/function.utils.js

@@ -0,0 +1,14 @@
+import { BackendServer } from "../server";
+const functionHandler = (config) => {
+    const server = new BackendServer();
+    let handler;
+    return async (eventContext) => {
+        if (!server.configured) {
+            server.configure(config.serverConfig);
+            config.routeRegistrationFn(server);
+            handler = server.start();
+        }
+        return await handler(eventContext);
+    };
+};
+export default functionHandler;

package/dist/utils/index.d.ts

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

package/dist/utils/index.js

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

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

@@ -0,0 +1,3 @@
+import { Input, MiddlewareHandler } from "hono";
+import { BaseHandler, Env } from "../types/api.types";
+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

@@ -0,0 +1,10 @@
+export function Or(...methods) {
+    return async (ctx, next) => {
+        const halt = async () => { };
+        const promises = methods.map(x => x(ctx, halt));
+        const values = await Promise.allSettled(promises);
+        if (!values.some(x => x.status === "fulfilled"))
+            throw values[0].reason;
+        await next();
+    };
+}

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

@@ -0,0 +1,4 @@
+import { DBFactory } from "../types";
+export declare const defaultCors: import("hono").MiddlewareHandler;
+export declare const bindDatabase: (getDB: DBFactory) => (ctx: any, next: any) => Promise<void>;
+export declare const defaultErrorHandler: (err: any, ctx: any) => any;

package/dist/utils/server.utils.js

@@ -0,0 +1,27 @@
+import { cors } from "hono/cors";
+import BaseModel from "../core/base.model";
+import { APIError } from "../core";
+export const defaultCors = cors({
+    origin: "*",
+    allowMethods: ["GET", "POST", "PUT", "PATCH", "DELETE", "OPTIONS"]
+});
+export const bindDatabase = (getDB) => {
+    return async (ctx, next) => {
+        if (!BaseModel.db)
+            BaseModel.db = getDB(ctx);
+        await next();
+    };
+};
+export const defaultErrorHandler = (err, ctx) => {
+    if (err instanceof APIError) {
+        ctx.status(err.statusCode || 500);
+        return ctx.json({
+            error_code: err.name,
+            error: err.message,
+            data: err.data
+        });
+    }
+    console.error(err);
+    ctx.status(500);
+    return ctx.json({ error: err.message });
+};

package/package.json

@@ -1,15 +1,7 @@
 {
   "name": "unconventional",
-  "version": "0.0.1",
+  "version": "0.0.3",
   "description": "A complete server built on Cloudflare Pages Functions",
-  "main": "index.js",
-  "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/cloudflare-extension/unconventional.git"
-  },
   "keywords": [
     "cloudflare",
     "pages",
@@ -18,12 +10,46 @@
     "edge",
     "server",
     "express",
-    "crud"
+    "crud",
+    "rest",
+    "api"
   ],
   "author": "Dean Mauro",
   "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/cloudflare-extension/unconventional.git"
+  },
   "bugs": {
     "url": "https://github.com/cloudflare-extension/unconventional/issues"
   },
-  "homepage": "https://github.com/cloudflare-extension/unconventional#readme"
+  "homepage": "https://github.com/cloudflare-extension/unconventional#readme",
+  "files": [
+    "dist"
+  ],
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "clean": "tsc --build --clean",
+    "build": "rm -rf dist && tsc --build",
+    "watch": "tsc --watch",
+    "lint": "eslint . --ext js,jsx,ts,tsx",
+    "format": "eslint . --ext js,jsx,ts,tsx --fix",
+    "docs:dev": "vitepress dev docs",
+    "docs:build": "vitepress build docs",
+    "docs:preview": "vitepress preview docs",
+    "docs:serve": "vitepress serve docs"
+  },
+  "peerDependencies": {
+    "hono": "^3.11.4",
+    "unconventional-pg-queries": "^0.0.5"
+  },
+  "devDependencies": {
+    "@cloudflare/workers-types": "^4.20231121.0",
+    "@typescript-eslint/eslint-plugin": "^5.62.0",
+    "@typescript-eslint/parser": "^5.62.0",
+    "hono": "^3.11.4",
+    "typescript": "^5.3.3",
+    "unconventional-pg-queries": "^0.0.5"
+  }
 }