unconventional 0.0.3 → 0.0.4

package/dist/decorators/prop.decorator.d.ts

@@ -1,4 +1,18 @@
 import BaseModel from '../core/base.model';
 import type { PropOptions } from '../types/decorator.types';
+/**
+ * Set Property Options for the property below
+ * @param options The Mongo options to Set
+ * @example
+ * ```ts
+ * class ClassName {
+ *   @prop()
+ *   public someProp?: string;
+ *
+ *   @prop({ type: String[] })
+ *   public someArrayProp?: string[];
+ * }
+ * ```
+ */
 declare function prop<Target = any, Source extends typeof BaseModel = any, Pivot extends typeof BaseModel = any>(options?: PropOptions<Target, Source, Pivot>): PropertyDecorator;
 export { prop as Prop, prop };

package/dist/decorators/prop.decorator.js

@@ -1,3 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prop = exports.Prop = void 0;
+/**
+ * Set Property Options for the property below
+ * @param options The Mongo options to Set
+ * @example
+ * ```ts
+ * class ClassName {
+ *   @prop()
+ *   public someProp?: string;
+ *
+ *   @prop({ type: String[] })
+ *   public someArrayProp?: string[];
+ * }
+ * ```
+ */
 function prop(options) {
     return (target, key) => {
         const parent = Object.getPrototypeOf(target.constructor);
@@ -10,4 +27,5 @@ function prop(options) {
         child.schema.props[key] = options || {};
     };
 }
-export { prop as Prop, prop };
+exports.Prop = prop;
+exports.prop = prop;

package/dist/decorators/timestamp.decorator.d.ts

@@ -1,4 +1,12 @@
 import { TimeStamped } from '../core/base.model';
 import { TypedClassDecorator } from '../types/decorator.types';
+/**
+ * Adds createdAt and updatedAt fields to the class and updates them on create/update calls.
+ * @example Example:
+ * ```ts
+ * ‎@timestamp()
+ * class ClassName {}
+ * ```
+ */
 export declare function timestamp<T extends typeof TimeStamped>(): TypedClassDecorator<T>;
 export { timestamp as Timestamp };

package/dist/decorators/timestamp.decorator.js

@@ -1,6 +1,18 @@
-export function timestamp() {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Timestamp = exports.timestamp = void 0;
+/**
+ * Adds createdAt and updatedAt fields to the class and updates them on create/update calls.
+ * @example Example:
+ * ```ts
+ * ‎@timestamp()
+ * class ClassName {}
+ * ```
+ */
+function timestamp() {
     return (target) => {
         target.schema.timestamped = true;
     };
 }
-export { timestamp as Timestamp };
+exports.timestamp = timestamp;
+exports.Timestamp = timestamp;

package/dist/decorators/utils.d.ts

@@ -1 +1,6 @@
+/**
+ * Returns the target name
+ * if target.constructor.name is "Function", return "target.name", otherwise "target.constructor.name"
+ * @param target The target to determine
+ */
 export declare function getName(target: any): any;

package/dist/decorators/utils.js

@@ -1,3 +1,12 @@
-export function getName(target) {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getName = void 0;
+/**
+ * Returns the target name
+ * if target.constructor.name is "Function", return "target.name", otherwise "target.constructor.name"
+ * @param target The target to determine
+ */
+function getName(target) {
     return target.constructor?.name === 'Function' ? target.name : target.constructor.name;
 }
+exports.getName = getName;

package/dist/index.js

@@ -1,5 +1,21 @@
-export * from './core';
-export * from './decorators';
-export * from './types';
-export * from './utils';
-export * from './server';
+"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("./core"), exports);
+__exportStar(require("./decorators"), exports);
+__exportStar(require("./types"), exports);
+__exportStar(require("./utils"), exports);
+__exportStar(require("./server"), exports);

package/dist/server.d.ts

@@ -2,6 +2,17 @@
 import { Hono } from "hono";
 import type { Env } from "./types/api.types";
 import type { ServerConfig } from "./types/server.types";
+/**
+ * A wrapper around Hono that provides some default configuration
+ * and a simple interface for starting the server.
+ *
+ * @example
+ * const server = new BackendServer({
+ *  name: "My Server",
+ *  basePath: "/api",
+ *  getDB: ctx => new DBProxy(ctx)
+ * });
+ */
 export declare class BackendServer {
     private _app;
     configured: boolean;

package/dist/server.js

@@ -1,12 +1,26 @@
-import { Hono } from "hono";
-import { handle } from "hono/cloudflare-pages";
-import { bindDatabase, defaultCors, defaultErrorHandler } from "./utils";
-import { cors } from "hono/cors";
-export class BackendServer {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BackendServer = void 0;
+const hono_1 = require("hono");
+const cloudflare_pages_1 = require("hono/cloudflare-pages");
+const utils_1 = require("./utils");
+const cors_1 = require("hono/cors");
+/**
+ * A wrapper around Hono that provides some default configuration
+ * and a simple interface for starting the server.
+ *
+ * @example
+ * const server = new BackendServer({
+ *  name: "My Server",
+ *  basePath: "/api",
+ *  getDB: ctx => new DBProxy(ctx)
+ * });
+ */
+class BackendServer {
     _app;
     configured = false;
     constructor(config) {
-        this._app = new Hono();
+        this._app = new hono_1.Hono();
         if (config)
             this.configure(config);
     }
@@ -16,17 +30,23 @@ export class BackendServer {
     configure(config) {
         if (this.configured)
             throw new Error("Cannot reconfigure server");
+        // Base path
         if (config.basePath)
             this._app = this._app.basePath(config.basePath);
-        this._app.use(bindDatabase(config.getDB));
-        this._app.use(config.cors ? cors(config.cors) : defaultCors);
-        this._app.onError(defaultErrorHandler);
+        // Database binding
+        this._app.use((0, utils_1.bindDatabase)(config.getDB));
+        // CORS
+        this._app.use(config.cors ? (0, cors_1.cors)(config.cors) : utils_1.defaultCors);
+        // Error handling
+        this._app.onError(utils_1.defaultErrorHandler);
+        // Standard middleware
         if (config.middleware)
             this._app.use(...config.middleware);
         this.configured = true;
         return this;
     }
     start() {
-        return handle(this._app);
+        return (0, cloudflare_pages_1.handle)(this._app);
     }
 }
+exports.BackendServer = BackendServer;

package/dist/types/api.types.js

@@ -1,17 +1,20 @@
-export var Query;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseEnvKey = exports.MaxCacheTTL = exports.DefaultCacheTTL = exports.CachePrefix = exports.Query = void 0;
+var Query;
 (function (Query) {
     Query["Expand"] = "expand";
-})(Query || (Query = {}));
-export var CachePrefix;
+})(Query || (exports.Query = Query = {}));
+var CachePrefix;
 (function (CachePrefix) {
     CachePrefix["Record"] = "rec_";
     CachePrefix["Page"] = "page_";
-})(CachePrefix || (CachePrefix = {}));
-export const DefaultCacheTTL = 900;
-export const MaxCacheTTL = 2147483647;
-export var BaseEnvKey;
+})(CachePrefix || (exports.CachePrefix = CachePrefix = {}));
+exports.DefaultCacheTTL = 900; // 15 minutes
+exports.MaxCacheTTL = 2147483647; // 68 years
+var BaseEnvKey;
 (function (BaseEnvKey) {
     BaseEnvKey["ownerId"] = "ownerId";
     BaseEnvKey["isPrivileged"] = "isPrivileged";
-})(BaseEnvKey || (BaseEnvKey = {}));
+})(BaseEnvKey || (exports.BaseEnvKey = BaseEnvKey = {}));
 ;

package/dist/types/db.types.js

@@ -1,12 +1,15 @@
-import { SqlDirection, SqlWhereOperator } from "unconventional-pg-queries";
-export const ValidSqlOperators = Object.values(SqlWhereOperator);
-export const NullSqlOperators = [SqlWhereOperator.IsNull, SqlWhereOperator.IsNotNull];
-export const ValidSortDirections = Object.values(SqlDirection);
-export const andOrPattern = /\s(?=AND|OR)/;
-export var SqlAction;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SqlAction = exports.andOrPattern = exports.ValidSortDirections = exports.NullSqlOperators = exports.ValidSqlOperators = void 0;
+const unconventional_pg_queries_1 = require("unconventional-pg-queries");
+exports.ValidSqlOperators = Object.values(unconventional_pg_queries_1.SqlWhereOperator);
+exports.NullSqlOperators = [unconventional_pg_queries_1.SqlWhereOperator.IsNull, unconventional_pg_queries_1.SqlWhereOperator.IsNotNull];
+exports.ValidSortDirections = Object.values(unconventional_pg_queries_1.SqlDirection);
+exports.andOrPattern = /\s(?=AND|OR)/;
+var SqlAction;
 (function (SqlAction) {
     SqlAction["Select"] = "SELECT";
     SqlAction["Insert"] = "INSERT";
     SqlAction["Update"] = "UPDATE";
     SqlAction["Delete"] = "DELETE";
-})(SqlAction || (SqlAction = {}));
+})(SqlAction || (exports.SqlAction = SqlAction = {}));

package/dist/types/decorator.types.d.ts

@@ -1,38 +1,69 @@
 import BaseModel from "../core/base.model";
 export declare type TypedClassDecorator<T> = (target: T) => T | void;
+/** Definition of a sortable index. 1=ascending, -1=descending */
 export type IndexDefinition<T> = {
     [P in keyof T]?: 1 | -1;
 };
+/** Options to pass to MongoDB when creating an Index */
 export interface IndexOptions {
     unique?: boolean;
 }
+/**
+ * Type for the Values stored in the Reflection for Indexes
+ * @example
+ * ```ts
+ * const indices: IIndexArray[] = Reflect.getMetadata(DecoratorKeys.Index, target) || []);
+ * ```
+ */
 export interface IndexSummary<T = any> {
     definition: IndexDefinition<T>;
     options?: IndexOptions;
 }
+/** Type of relational field between two models */
 export declare enum RelationType {
     HasOne = 0,
     HasMany = 1,
     ManyToMany = 2,
     BelongsTo = 3
 }
+/** Details of the pivot table connecting two models */
 export interface RelationPivot<T extends typeof BaseModel = any> {
+    /** The model to use for the pivot table */
     model: T;
+    /** The field on this model related to the source */
     from: keyof InstanceType<T>;
+    /** The field on this model related to the target */
     to: keyof InstanceType<T>;
 }
 export interface Relation<Target extends typeof BaseModel = any, Source extends typeof BaseModel = any, Pivot extends typeof BaseModel = any> {
+    /** The type of relation */
     type: RelationType;
+    /** The model to relate to */
     model: Target;
+    /** The field on this model to use for the relation */
     from: keyof InstanceType<Source>;
+    /** The field on the related model to use for the relation */
     to: keyof InstanceType<Target>;
+    /** Details of the pivot table connecting this model to the related model */
     through?: RelationPivot<Pivot>;
 }
+/** Options to pass to MongoDB when creating or validating a property */
 export interface PropOptions<T = any, S extends typeof BaseModel = any, P extends typeof BaseModel = any> {
+    /**
+     * Is this value required?
+     * @default false
+     */
     required?: boolean;
+    /** Is this Property unique?
+     * @default false
+     */
     unique?: boolean;
+    /** Only accept Values from the Enum(|Array) */
     enum?: any;
+    /** Give the Property a default Value */
     default?: T | (() => T);
+    /** Relational field data */
     relation?: T extends typeof BaseModel ? Relation<T, S, P> : never;
 }
+/** Type for the Values stored in the Reflection for Properties */
 export type PropSummary<Target = any, Source extends typeof BaseModel = any> = Record<keyof Source, PropOptions<Target, Source>>;

package/dist/types/decorator.types.js

@@ -1,7 +1,14 @@
-export var RelationType;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RelationType = void 0;
+//#endregion
+//#region Relation
+/** Type of relational field between two models */
+var RelationType;
 (function (RelationType) {
     RelationType[RelationType["HasOne"] = 0] = "HasOne";
     RelationType[RelationType["HasMany"] = 1] = "HasMany";
     RelationType[RelationType["ManyToMany"] = 2] = "ManyToMany";
     RelationType[RelationType["BelongsTo"] = 3] = "BelongsTo";
-})(RelationType || (RelationType = {}));
+})(RelationType || (exports.RelationType = RelationType = {}));
+//#endregion

package/dist/types/index.js

@@ -1,4 +1,20 @@
-export * from './api.types';
-export * from './db.types';
-export * from './decorator.types';
-export * from './server.types';
+"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.types"), exports);
+__exportStar(require("./db.types"), exports);
+__exportStar(require("./decorator.types"), exports);
+__exportStar(require("./server.types"), exports);

package/dist/types/server.types.js

@@ -1 +1,2 @@
-export {};
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/utils/api.utils.d.ts

@@ -1,8 +1,23 @@
 import { AndOr } from "unconventional-pg-queries";
+/**
+ * Decompose an expand-formatted string into an array of its parts.
+ * @example
+ * parseExpandString('a,b,c') // ['a', 'b', 'c']
+ * parseExpandString('a[b,c],d[e,f],g') // ['a[b,c]', 'd[e,f]', 'g']
+ */
 export declare function parseExpandString(expand: string): string[];
+/**
+ * Split an expand-formatted into its parent and child parts.
+ * @example
+ * splitExpandUnit('a') // { parent: 'a', children: '' }
+ * splitExpandUnit('a[b,c]') // { parent: 'a', children: 'b,c' }
+ * splitExpandUnit('a[b,c[d,e]]') // { parent: 'a', children: 'b,c[d,e]' }
+ */
 export declare function splitExpandUnit(input: string): {
     parent: string;
     children: string;
 };
+/** Parse a filter string and replace clauses that reference the target field with the provided replacement. */
 export declare function replaceFilter(filter: string | string[] | undefined, target: string, replacement: string, andOr?: AndOr): string;
+/** Check if the filter has the specified target field. */
 export declare function hasFilter(filter: string | string[] | undefined, target: string): boolean;

package/dist/utils/api.utils.js

@@ -1,9 +1,18 @@
-import { AndOr } from "unconventional-pg-queries";
-import { andOrPattern } from "../types/db.types";
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasFilter = exports.replaceFilter = exports.splitExpandUnit = exports.parseExpandString = void 0;
+const unconventional_pg_queries_1 = require("unconventional-pg-queries");
+const db_types_1 = require("../types/db.types");
 const defaultTarget = ',';
 const openBracket = '[';
 const closeBracket = ']';
-export function parseExpandString(expand) {
+/**
+ * Decompose an expand-formatted string into an array of its parts.
+ * @example
+ * parseExpandString('a,b,c') // ['a', 'b', 'c']
+ * parseExpandString('a[b,c],d[e,f],g') // ['a[b,c]', 'd[e,f]', 'g']
+ */
+function parseExpandString(expand) {
     const text = expand.trim();
     if (!text)
         return [];
@@ -11,36 +20,53 @@ export function parseExpandString(expand) {
     let word = '';
     let bracketCount = 0;
     for (const char of text) {
+        // If we encounter a comma and we're not inside brackets, push the word
         if (bracketCount === 0 && char === defaultTarget) {
             result.push(`${word}`);
             word = '';
+            // Otherwise, add the character to the word
         }
         else {
             word += char;
+            // If we encounter a bracket, increment or decrement the bracket count
             if (char === openBracket)
                 bracketCount++;
             else if (char === closeBracket)
                 bracketCount--;
         }
     }
+    // Push the last word
     result.push(`${word}`);
     return result;
 }
-export function splitExpandUnit(input) {
+exports.parseExpandString = parseExpandString;
+/**
+ * Split an expand-formatted into its parent and child parts.
+ * @example
+ * splitExpandUnit('a') // { parent: 'a', children: '' }
+ * splitExpandUnit('a[b,c]') // { parent: 'a', children: 'b,c' }
+ * splitExpandUnit('a[b,c[d,e]]') // { parent: 'a', children: 'b,c[d,e]' }
+ */
+function splitExpandUnit(input) {
     const index = input.indexOf(openBracket);
     if (index === -1)
         return { parent: input, children: '' };
     return { parent: input.slice(0, index), children: input.slice(index + 1, -1) };
 }
-export function replaceFilter(filter, target, replacement, andOr = AndOr.And) {
+exports.splitExpandUnit = splitExpandUnit;
+/** Parse a filter string and replace clauses that reference the target field with the provided replacement. */
+function replaceFilter(filter, target, replacement, andOr = unconventional_pg_queries_1.AndOr.And) {
     if (!filter)
         return replacement;
-    const otherFilters = filter.split(andOrPattern).flatMap(x => x.includes(target) ? [] : x);
+    const otherFilters = filter.split(db_types_1.andOrPattern).flatMap(x => x.includes(target) ? [] : x);
     otherFilters.push(`${otherFilters.length ? `${andOr} ` : ''}${replacement}`);
     return otherFilters.join(' ');
 }
-export function hasFilter(filter, target) {
+exports.replaceFilter = replaceFilter;
+/** Check if the filter has the specified target field. */
+function hasFilter(filter, target) {
     if (!filter)
         return false;
-    return filter.split(andOrPattern).some(x => x.startsWith(target));
+    return filter.split(db_types_1.andOrPattern).some(x => x.startsWith(target));
 }
+exports.hasFilter = hasFilter;

package/dist/utils/array.utils.d.ts

@@ -1,2 +1,4 @@
+/** Compares two arrays and returns true if they contain the same elements, regardless of order */
 export declare const equalArrays: <T>(a: T[], b: T[]) => boolean;
+/** Checks whether an object has no keys and/or the value for every key is undefined */
 export declare function isEmpty(obj: any): boolean;

package/dist/utils/array.utils.js

@@ -1,4 +1,8 @@
-export const equalArrays = (a, b) => {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isEmpty = exports.equalArrays = void 0;
+/** Compares two arrays and returns true if they contain the same elements, regardless of order */
+const equalArrays = (a, b) => {
     if (a.length !== b.length)
         return false;
     const clone = [...b];
@@ -12,9 +16,12 @@ export const equalArrays = (a, b) => {
     }
     return clone.length === 0;
 };
-export function isEmpty(obj) {
+exports.equalArrays = equalArrays;
+/** Checks whether an object has no keys and/or the value for every key is undefined */
+function isEmpty(obj) {
     for (const key in obj)
         if (obj[key] !== undefined)
             return false;
     return true;
 }
+exports.isEmpty = isEmpty;

package/dist/utils/cache.utils.js

@@ -1,14 +1,21 @@
-import { DefaultCacheTTL } from "../types/api.types";
-export async function getCachedOrFetch(cache, key, fetchFn, ttl = DefaultCacheTTL) {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCachedOrFetch = void 0;
+const api_types_1 = require("../types/api.types");
+async function getCachedOrFetch(cache, key, fetchFn, ttl = api_types_1.DefaultCacheTTL) {
+    // Check cache first
     if (cache) {
         const cachedResponse = await cache.get(key);
         if (cachedResponse) {
             return JSON.parse(cachedResponse);
         }
     }
+    // If not cached, fetch
     const response = await fetchFn();
+    // Cache if successful
     if (response && cache) {
         await cache.put(key, JSON.stringify(response), { expirationTtl: ttl });
     }
     return response;
 }
+exports.getCachedOrFetch = getCachedOrFetch;

package/dist/utils/crypto.utils.d.ts

@@ -1 +1,2 @@
+/** Hashes the given value using SHA-256 */
 export declare function sha256(value: string): Promise<string>;

package/dist/utils/crypto.utils.js

@@ -1,7 +1,13 @@
-export function sha256(value) {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sha256 = void 0;
+/** Hashes the given value using SHA-256 */
+function sha256(value) {
     var buffer = new TextEncoder().encode(value);
     return crypto.subtle.digest("SHA-256", buffer).then(hex);
 }
+exports.sha256 = sha256;
+/** Encodes a buffer in hex notation */
 function hex(buffer) {
     return [...new Uint8Array(buffer)]
         .map(b => b.toString(16).padStart(2, '0'))

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

@@ -1,9 +1,14 @@
 import { ConflictResolution, Expansion, SqlConflict, SqlOrder, SqlPaginate, SqlWhere, SqlWhereOperator } from "unconventional-pg-queries";
 import BaseModel from "../core/base.model";
+/** Converts a stringified list of relational fields to an array of data needed to expand those fields in a SQL environment  */
 export declare function getExpand<T extends typeof BaseModel>(model: T, expand?: string): Record<string, Expansion>;
+/** Converts a string of filters to an array of 'where' clause outlines for a SQL environment */
 export declare function getWhere<T extends typeof BaseModel>(model: T, filterString?: string): SqlWhere[];
+/** Converts a stringified list of fields to order ascending or descending to an array of order data for a SQL environment */
 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;
+/** Retrieves all non-relational fields from a model for the 'returning' clause of a SQL call */
 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;
+/** A type-safe way to build filter strings */
 export declare function buildFilter<T>(field: keyof T, operator: SqlWhereOperator, value?: any): string;