ivl 0.2.7 → 0.3.0

package/README.md

@@ -112,8 +112,8 @@ export const LOGIN_SCHEMA: SCHEMA =  {
 };
 
 export const REGISTER_SCHEMA: SCHEMA = {
-	// We can pass in an empty rule set to allow any value
-	// Or we can omit the argument entirely and set the strict flag to false when checking the schema
+  // We can pass in an empty rule set to allow any value
+  // Or we can omit the argument entirely and set the strict flag to false when checking the schema
   organization_name: {}
   email: {
     ...EMAIL_REQUIREMENTS,
@@ -137,17 +137,17 @@ export const INVITATION_PARAM: SCHEMA = {
 
 ### `index.ts`
 ```typescript
-import { Hono } from 'hono';
+import { Hono, ValidationTargets } from 'hono';
 import { validator } from 'hono/validator';
 import { getSchemaErrors } from 'ivl';
 import { LOGIN_SCHEMA, REGISTER_SCHEMA, INVITE_REGISTER_SCHEMA, INVITATION_PARAM } from './rules.ts';
 
 // Wrapper for hono validator middleware
-const validateWrapper = async (input_type:string, schema: SCHEMA) => 
-	validate(input_type, async (value: any, c: Context) => {
+export const validate = (input_type: keyof ValidationTargets, schema: SCHEMA) =>
+  validator(input_type, async (value: CHECKABLE_OBJECT) => {
     const errors = await getSchemaErrors(value, schema, { strict: true });
     if (Object.values(errors).filter((e) => e.length).length) {
-      throw new HTTPException(error, {
+      throw new HTTPException(400, {
         message: JSON.stringify(errors),
       });
     }
@@ -157,20 +157,20 @@ const validateWrapper = async (input_type:string, schema: SCHEMA) =>
 const app = new Hono();
 
 app.post('/login',
-	validateWrapper('json', LOGIN_SCHEMA),
+  validate('json', LOGIN_SCHEMA),
   (c) => c.text("Success"));
 
 app.all('/logout', (c) => c.text("Success"));
 
 app.put('/register', 
-  validateWrapper('json', REGISTER_SCHEMA),
+  validate('json', REGISTER_SCHEMA),
   (c) => c.text("Success"));
 
 // This first validates the invitation parameter against our database
 // And then validates the body of the request
 app.put('/register/:invitation_code',
-  validateWrapper('param', INVITATION_PARAM),
-  validateWrapper('json', INVITE_REGISTER_SCHEMA ),
+  validate('param', INVITATION_PARAM),
+  validate('json', INVITE_REGISTER_SCHEMA ),
   (c)=> c.text("Success"));
 
 export default app;

package/lib/helpers/index.d.ts

@@ -13,9 +13,17 @@ export declare const maxLength: (max_length?: number) => RULE_SYNC;
 export declare const minLength: (min_length?: number) => RULE_SYNC;
 export declare const stringBetween: (max?: number, min?: number) => RULE_SYNC;
 export declare const numberBetween: (max?: number, min?: number) => RULE_SYNC;
-export declare const acceptAny: (rules?: RULE[]) => RULE;
+export declare const acceptAnyAsync: (rules?: RULE[]) => RULE;
 export declare const acceptAnySync: (rules?: RULE_SYNC[]) => RULE_SYNC;
-export declare const allowUndefined: (rules: RULES) => {};
-export declare const preprocess: (fn: Function, rules: RULES) => {};
+declare const allowUndefined: (rules: RULES) => {};
+declare const preprocess: (fn: Function, rules: RULES) => {};
+
+declare namespace ruleSet {
+	export { allowUndefined, preprocess };
+}
+
+export {
+	ruleSet,
+};
 
 export {};

package/lib/helpers/index.js

@@ -1 +1 @@
-var s=(n)=>typeof n==="string"||n!==null&&typeof n==="object"&&("length"in n)&&typeof n.length==="number",c=(n)=>(e)=>typeof e===n,i=(n)=>(e)=>typeof e==="string"&&n.test(e),f=(n=1/0)=>(e)=>typeof e==="number"&&e<=n,m=(n=-1/0)=>(e)=>typeof e==="number"&&e>=n,y=(n=1/0)=>(e)=>s(e)&&e.length<=n,w=(n=0)=>(e)=>s(e)&&e.length>=n,a=(n=1/0,e=0)=>(t)=>typeof t==="string"&&t.length>=e&&t.length<=n,L=(n=1/0,e=-1/0)=>(t)=>typeof t==="number"&&t>=e&&t<=n,g=(n=[])=>async(e,...t)=>(await Promise.all(n.map((o)=>o(void 0,e,...t)))).some((o)=>o),h=(n=[])=>(e,...t)=>n.map((o)=>o(void 0,e,...t)).some((o)=>o);var l=(n)=>Object.entries(n).reduce((e,[t,o])=>({...e,[t]:(r,...u)=>typeof r==="undefined"?!0:o(r,...u)}),{}),x=(n,e)=>Object.entries(e).reduce((t,[o,r])=>({...t,[o]:(u,...p)=>r(n(u),...p)}),{});export{a as stringBetween,x as preprocess,L as numberBetween,w as minLength,m as min,y as maxLength,f as max,i as matchesRegex,c as isType,l as allowUndefined,h as acceptAnySync,g as acceptAny};
+var i=Object.defineProperty;var m=(e,n)=>{for(var t in n)i(e,t,{get:n[t],enumerable:!0,configurable:!0,set:(o)=>n[t]=()=>o})};var u=(e)=>typeof e==="string"||e!==null&&typeof e==="object"&&("length"in e)&&typeof e.length==="number",a=(e)=>(n)=>typeof n===e,L=(e)=>(n)=>typeof n==="string"&&e.test(n),g=(e=1/0)=>(n)=>typeof n==="number"&&n<=e,h=(e=-1/0)=>(n)=>typeof n==="number"&&n>=e,l=(e=1/0)=>(n)=>u(n)&&n.length<=e,R=(e=0)=>(n)=>u(n)&&n.length>=e,x=(e=1/0,n=0)=>(t)=>typeof t==="string"&&t.length>=n&&t.length<=e,E=(e=1/0,n=-1/0)=>(t)=>typeof t==="number"&&t>=n&&t<=e,U=(e=[])=>async(n,...t)=>(await Promise.all(e.map((o)=>o(n,...t)))).some((o)=>o),b=(e=[])=>(n,...t)=>e.map((o)=>o(n,...t)).some((o)=>o);var p={};m(p,{preprocess:()=>f,allowUndefined:()=>y});var y=(e)=>Object.entries(e).reduce((n,[t,o])=>({...n,[t]:(r,...s)=>typeof r==="undefined"?!0:o(r,...s)}),{}),f=(e,n)=>Object.entries(n).reduce((t,[o,r])=>({...t,[o]:(s,...c)=>r(e(s),...c)}),{});export{x as stringBetween,p as ruleSet,E as numberBetween,R as minLength,h as min,l as maxLength,g as max,L as matchesRegex,a as isType,b as acceptAnySync,U as acceptAnyAsync};

package/lib/index.d.ts

@@ -9,31 +9,31 @@ export type RULES = {
 	[index: string]: RULE;
 };
 export type SCHEMA_SYNC = {
-	[index: string]: RULES_SYNC;
+	[index: string]: RULES_SYNC | RULES_SYNC[];
 };
 export type SCHEMA = {
-	[index: string]: RULES;
-};
-export type CHECKABLE_OBJECT = {
-	[index: string]: unknown;
+	[index: string]: RULES | RULES[];
 };
 /**
  * @arg {boolean} strict --- Don't allow object to have keys not included in the schema
- */
+*/
 export type SCHEMA_OPTIONS = {
 	strict?: boolean;
 };
-export type CHECKED_SCHEMA_SYNC = {
-	[index: string]: string[];
+export type CHECKABLE_OBJECT = {
+	[index: string]: unknown;
 };
-export type CHECKED_SCHEMA = Promise<CHECKED_SCHEMA_SYNC>;
+export type CHECKED_SCHEMA_SYNC<T extends keyof CHECKABLE_OBJECT> = {
+	[K in T]: string[] | string[][];
+};
+export type CHECKED_SCHEMA<T extends keyof CHECKABLE_OBJECT> = Promise<CHECKED_SCHEMA_SYNC<T>>;
 /**
  * Detect if a RULES object has any async rules in it
  *
- * @param {Record<string, RULE>} rules a rules object
+ * @param {Record<string, RULE>|Record<string, RULE>[]} rules a rules object
  * @returns {boolean} true if any of the rules is an async function otherwise false
  */
-export declare const hasAsyncFunction: (rules: Record<string, RULE>) => boolean;
+export declare const hasAsyncFunction: (rules: Record<string, RULE> | Record<string, RULE>[]) => boolean;
 /**
  * Check the input against all provided validation rules asynchronously
  *
@@ -46,13 +46,15 @@ export declare const getValueErrorsAsync: (value: unknown, rules: RULES, ...over
 /**
  * Check a schema against all provided validation rules asynchronously
  *
- * @param {CHECKABLE_OBJECT} object object to be validated
+ * @param {CHECKABLE_OBJECT} object_to_check object to be validated
  * @param {SCHEMA} schema schema to validate against
  * @param {SCHEMA_OPTIONS} options options affecting how the rules are run
  * @param {unknown[]} overload array of extra values the validator rules might need to properly validate the value
- * @returns {CHECKED_SCHEMA} an object containing keys and their respective lists of failed rule names
+ * @returns {CHECKED_SCHEMA<T>} an object containing keys and their respective lists of failed rule names
  */
-export declare const getSchemaErrorsAsync: (object: CHECKABLE_OBJECT, schema: SCHEMA, options?: SCHEMA_OPTIONS, ...overload: unknown[]) => CHECKED_SCHEMA;
+export declare const getSchemaErrorsAsync: <T extends keyof CHECKABLE_OBJECT>(object_to_check: Pick<CHECKABLE_OBJECT, T>, schema: {
+	[K in T]: RULES | RULES[];
+}, options?: SCHEMA_OPTIONS, ...overload: unknown[]) => Promise<CHECKED_SCHEMA_SYNC<T>>;
 /**
  *
  * @param {unknown} value the value to check
@@ -68,26 +70,25 @@ export declare const getValueErrorsSync: (value: unknown, rules: RULES_SYNC, ...
 * @param {SCHEMA} schema schema to validate against
 * @param {SCHEMA_OPTIONS} options options affecting how the rules are run
 * @param {unknown[]} overload array of extra values the validator rules might need to properly validate the value
-* @returns {CHECKED_SCHEMA} an object containing keys and their respective lists of failed rule names
+* @returns {CHECKED_SCHEMA_SYNC<T>} an object containing keys and their respective lists of failed rule names
 */
-export declare const getSchemaErrorsSync: (object: CHECKABLE_OBJECT, schema: SCHEMA_SYNC, options?: SCHEMA_OPTIONS, ...overload: unknown[]) => CHECKED_SCHEMA_SYNC;
+export declare const getSchemaErrorsSync: <T extends keyof CHECKABLE_OBJECT>(object: CHECKABLE_OBJECT, schema: SCHEMA_SYNC, options?: SCHEMA_OPTIONS, ...overload: unknown[]) => CHECKED_SCHEMA_SYNC<T>;
 /**
- *
  * @param {unknown} value the value to check
  * @param {RULES|RULES_SYNC} rules rules object to use for validating the provided value
  * @param {unknown[]} overload array of extra values the validator rules might need to properly validate the value
- * @returns {string[]} a list of rule names which failed validation
+ * @returns {Promise<string[]>|string[]} a list of rule names which failed validation
  */
-export declare const getValueErrors: (value: unknown, rules: RULES | RULES_SYNC, ...overload: unknown[]) => string[] | Promise<string[]>;
+export declare const getValueErrors: (value: unknown, rules: RULES | RULES_SYNC, ...overload: unknown[]) => Promise<string[]> | string[];
 /**
  * Check a schema against all provided validation rules
  *
  * @param {CHECKABLE_OBJECT} object object to be validated
- * @param {SCHEMA} schema schema to validate against
+ * @param {SCHEMA|SCHEMA_SYNC} schema schema to validate against
  * @param {SCHEMA_OPTIONS} options options affecting how the rules are run
  * @param {unknown[]} overload array of extra values the validator rules might need to properly validate the value
  * @returns {CHECKED_SCHEMA} an object containing keys and their respective lists of failed rule names
  */
-export declare const getSchemaErrors: (object: CHECKABLE_OBJECT, schema: SCHEMA_SYNC | SCHEMA, options?: SCHEMA_OPTIONS, ...overload: unknown[]) => CHECKED_SCHEMA_SYNC | CHECKED_SCHEMA;
+export declare const getSchemaErrors: <T extends keyof CHECKABLE_OBJECT>(object: CHECKABLE_OBJECT, schema: SCHEMA_SYNC | SCHEMA, options?: SCHEMA_OPTIONS, ...overload: unknown[]) => CHECKED_SCHEMA<T> | CHECKED_SCHEMA_SYNC<T>;
 
 export {};

package/lib/index.js

@@ -1 +1 @@
-var Z={strict:!1},$=(z)=>Object.values(z).some((q)=>typeof q==="function"&&q.constructor.name==="AsyncFunction"),J=async(z,q,...W)=>{const G={};return Object.entries(q).forEach(([x,Q])=>{G[x]=Promise.resolve(!1).then(()=>Q(z,...W)).then((R)=>G[x]=R).catch((R)=>{return console.warn(`Rule validation functions for "${x}" didn't exit cleanly`,R),G[x]=!1})}),await Promise.allSettled(Object.values(G)),Object.entries(G).reduce((x,[Q,R])=>R?x:[...x,Q],[])},K=async(z,q,W=Z,...G)=>{const x={};if(Object.entries(q).forEach(([Q,R])=>{x[Q]=J(z[Q],R,...G).then((X)=>{x[Q]=X}).catch((X)=>{x[Q]=X})}),W.strict){const Q=Object.keys(z),R=new Set(Object.keys(q));Q.filter((Y)=>!R.has(Y)).forEach((Y)=>{x[Y]=["Key not allowed"]})}return await Promise.allSettled(Object.values(x)),x},B=(z,q,...W)=>Object.entries(q).reduce((G,[x,Q])=>{try{return Q(z,...W)?G:[...G,x]}catch(R){return console.warn(`Rule validation function for "${x}" didn't exit cleanly`,R),[...G,x]}},[]),f=(z,q,W=Z,...G)=>{const x=Object.entries(q).reduce((Q,[R,X])=>({...Q,[R]:B(z[R],X,...G)}),{});if(W.strict){const Q=Object.keys(z),R=new Set(Object.keys(q));Q.filter((Y)=>!R.has(Y)).forEach((Y)=>{x[Y]=["Key not allowed"]})}return x},U=(z,q,...W)=>{if($(q))return J(z,q,...W);return B(z,q,...W)},I=(z,q,W=Z,...G)=>{if(Object.values(q).some($))return K(z,q,W,...G);return f(z,q,W,...G)};export{$ as hasAsyncFunction,B as getValueErrorsSync,J as getValueErrorsAsync,U as getValueErrors,f as getSchemaErrorsSync,K as getSchemaErrorsAsync,I as getSchemaErrors};
+var K={strict:!1},U=(x)=>{if(Array.isArray(x))return x.some((z)=>Object.values(z).some((W)=>typeof W==="function"&&W.constructor.name==="AsyncFunction"));return Object.values(x).some((z)=>typeof z==="function"&&z.constructor.name==="AsyncFunction")},Y=async(x,z,...W)=>{const Q={};return Object.entries(z).forEach(([G,X])=>{Q[G]=Promise.resolve(!1).then(()=>X(x,...W)).then((q)=>Q[G]=q).catch(()=>{return Q[G]=!1})}),await Promise.allSettled(Object.values(Q)),Object.entries(Q).reduce((G,[X,q])=>q?G:[...G,X],[])},I=async(x,z,W=K,...Q)=>{const G={},X=[];if(Object.entries(z).forEach(([q,$])=>{let Z;if(Array.isArray($))Z=Promise.allSettled($.map((R)=>Y(x[q],R,...Q))).then((R)=>{const f=R.map((J)=>{if(J.status==="fulfilled")return J.value;return["Unknown error occurred"]},[]);if(f.some((J)=>!J.length))G[q]=[];else G[q]=f}).catch((R)=>{if(R instanceof Error)G[q]=[R.message];else G[q]=["Unknown error occurred"]});else Z=Y(x[q],$,...Q).then((R)=>{G[q]=R}).catch((R)=>{G[q]=R});X.push(Z)}),W.strict){const q=Object.keys(x),$=new Set(Object.keys(z));q.filter((R)=>!$.has(R)).forEach((R)=>{G[R]=["Key not allowed"]})}return await Promise.allSettled(X),G},B=(x,z,...W)=>Object.entries(z).reduce((Q,[G,X])=>{try{return X(x,...W)?Q:[...Q,G]}catch(q){return[...Q,G]}},[]),L=(x,z,W=K,...Q)=>{const G=Object.entries(z).reduce((X,[q,$])=>{if(Array.isArray($)){const Z=$.map((R)=>B(x[q],R,...Q));if(Z.some((R)=>!R.length))return{...X,[q]:[]};return{...X,[q]:Z}}return{...X,[q]:B(x[q],$,...Q)}},{});if(W.strict){const X=Object.keys(x),q=new Set(Object.keys(z));X.filter((Z)=>!q.has(Z)).forEach((Z)=>{G[Z]=["Key not allowed"]})}return G},D=(x,z,...W)=>{if(U(z))return Y(x,z,...W);return B(x,z,...W)},w=(x)=>Object.values(x).some(U),F=(x,z,W=K,...Q)=>{if(w(z))return I(x,z,W,...Q);return L(x,z,W,...Q)};export{U as hasAsyncFunction,B as getValueErrorsSync,Y as getValueErrorsAsync,D as getValueErrors,L as getSchemaErrorsSync,I as getSchemaErrorsAsync,F as getSchemaErrors};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ivl",
-  "version": "0.2.7",
+  "version": "0.3.0",
   "author": {
     "name": "Oskar Voorel",
     "email": "oskar@voorel.com"