ivl 0.3.1 → 0.4.1

package/README.md

@@ -2,9 +2,9 @@
 This is a lightweight library for user input validation.
 Main focus is on speed and flexibility of the validation rules.
 
-By default `getInputErrors` and `getSchemaErrors` automatically detects and chooses the most performant checking method for your rule set.
+By default `getValueErrors` and `getSchemaErrors` automatically detects and chooses the most performant checking method for your rule set.
 
-If your rule set and/or schema are very large or complex, you may want to directly use `getInputErrorsSync`/`getSchemaErrorsSync` or `getInputErrorsAsync`/`getSchemaErrorsAsync` for improved performance on synchronous and asynchronous rule sets respectively.
+If your rule set and/or schema are very large or complex, you may want to directly use `getValueErrorsSync`/`getSchemaErrorsSync` or `getValueErrorsAsync`/`getSchemaErrorsAsync` for improved performance on synchronous and asynchronous rule sets respectively.
 
 Use synchronous versions of the functions for better performance if you don't need to support asynchronous checks on your inputs. 
 
@@ -16,10 +16,41 @@ const my_rules = {
   "Input must be more than 40": (i) => i > 40,
   "Input must be divisible by 10": (i) => !(i % 10)
 }
-console.log(getInputErrors(50, my_rules)); // []
-console.log(getInputErrors(11, my_rules)); // ["Input must be more than 40", "Input must be divisible by 10"]
-console.log(getInputErrors(30, my_rules)) // ["Input must be more than 40"]
+console.log(getValueErrors(50, my_rules)); // []
+console.log(getValueErrors(11, my_rules)); // ["Input must be more than 40", "Input must be divisible by 10"]
+console.log(getValueErrors(30, my_rules)) // ["Input must be more than 40"]
 ```
+# Type inference
+`getValueErrors` and `getSchemaErrors` infer their return type from the rules you pass in:
+
+```typescript
+const sync_rules = { "Is string": (i: unknown) => typeof i === 'string' };
+const async_rules = { "Exists": async (i: unknown) => await lookup(i) };
+
+getValueErrors('x', sync_rules);  // string[]
+getValueErrors('x', async_rules); // Promise<string[]>
+
+const errors = getSchemaErrors(input, {
+  name: sync_rules,
+  ids: [sync_rules, { "Is number": (i: unknown) => typeof i === 'number' }],
+});
+errors.name; // string[]
+errors.ids;  // string[][] - one error list per alternative rule set
+```
+
+Rules and rule sets are generic over the value type and any extra "overload" arguments:
+
+```typescript
+import type { RULE } from 'ivl';
+
+// A rule that only accepts strings and needs a context object passed as an overload
+const inDatabase: RULE<string, [ctx: { db: Database }]> = async (value, ctx) => ctx.db.has(value);
+```
+
+> **Note:** annotating a rule set as `RULES` (or a schema as `SCHEMA`) widens every rule to
+> "may be sync or async", so the return type becomes `string[] | Promise<string[]>`. Prefer
+> `satisfies RULES` / `satisfies SCHEMA`, which validates the shape without losing the inferred types.
+
 # Installing
 ```typescript
 bun add ivl // bun.js
@@ -35,44 +66,46 @@ pnpm install ivl // pnpm
 ## Frontend example
 ### `index.ts`
 ```typescript
-import { getInputErrors } from 'ivl';
+import { getValueErrors } from 'ivl';
 import type { RULES } from 'ivl';
 import { matchesRegex, minLength, maxLength, isType } from 'ivl/helpers';
 
 // This pattern is also exportable from 'ivl/patterns'
 const EMAIL_PATTERN = /^[\w.%+-]+@[\w.-]+\.[a-zA-Z]{1,}$/;
 
-const EMAIL_REQUIREMENTS: RULES = {
+// `satisfies` checks the object against RULES while keeping each rule's exact type,
+// so `getValueErrors` can infer that this rule set is async.
+const EMAIL_REQUIREMENTS = {
   "Must be string": isType('string'),
   "Must be less then 100 characters": maxLength(100),
   "Not a valid email address": matchesRegex(EMAIL_PATTERN),
-  "That email is already in use": async (i) => {
+  "That email is already in use": async (i: unknown) => {
     // Fetch info from whatever backend and make a decision based on that asynchronously
     const email_in_use = await fetch(`https://mybackend/email-exists/${i}`)
     return !email_in_use // We will return true if the email is not already taken
   }
-};
+} satisfies RULES;
 
-const PASSWORD_REQUIREMENTS: RULES = {
+const PASSWORD_REQUIREMENTS = {
   "Must be string": isType('string'),
   "Must be at least 8 characters": minLength(8),
   "Must contain at least one upper case character": matchesRegex(/[A-Z]/),
   "Must contain at least one lower case character": matchesRegex(/[a-z]/),
-};
+} satisfies RULES;
 
 // You can of course expand on your existing rules: 
-const STRONG_PASSWORD_REQUIREMENTS: RULES = {
+const STRONG_PASSWORD_REQUIREMENTS = {
   ...PASSWORD_REQUIREMENTS,
   "Must contain at least one digit": matchesRegex(/\d/),
   "Must contain at least one symbol": matchesRegex(/[^\w\s]/),
-};
+} satisfies RULES;
 
 const email_value = "some-value";
 const pw_value = "Passesweakpw";
 
-const email_errors = getInputErrors(email_value, EMAIL_REQUIREMENTS);
-const pw_errors = getInputErrors(pw_value, PASSWORD_REQUIREMENTS);
-const strong_pw_errors = getInputErrors(pw_value, STRONG_PASSWORD_REQUIREMENTS);
+const email_errors = await getValueErrors(email_value, EMAIL_REQUIREMENTS); // Promise<string[]> - one rule is async
+const pw_errors = getValueErrors(pw_value, PASSWORD_REQUIREMENTS);             // string[] - all rules are sync
+const strong_pw_errors = getValueErrors(pw_value, STRONG_PASSWORD_REQUIREMENTS); // string[]
 
 console.log({email_errors, pw_errors, strong_pw_errors});
 ```
@@ -84,7 +117,7 @@ console.log({email_errors, pw_errors, strong_pw_errors});
 ```typescript
 import { isType, minLength, maxLength, matchesRegex } from 'ivl/helpers';
 import { EMAIL_PATTERN } from 'ivl/patterns';
-import type { SCHEMA } from 'ivl';
+import type { RULE, SCHEMA } from 'ivl';
 import { checkValueInDatabase } from 'my-database-controller';
 
 const existsInDatabase = (key: string, table: string, exists: boolean = true): RULE =>
@@ -114,7 +147,7 @@ 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
-  organization_name: {}
+  organization_name: {},
   email: {
     ...EMAIL_REQUIREMENTS,
     "Email already registered": existsInDatabase('email','users', false)
@@ -125,7 +158,7 @@ export const REGISTER_SCHEMA: SCHEMA = {
 // Registering via invitation needs all the same values except organization name
 // inherit parts of rule sets, as opposed to extending the rule set as show in the
 // frontend example
-export const INVITE_REGISTER_SCHEMA = (({ organization_name, ...invite_schema }) => invite_schema)(REGISTRATION_SCHEMA)
+export const INVITE_REGISTER_SCHEMA = (({ organization_name, ...invite_schema }) => invite_schema)(REGISTER_SCHEMA)
 
 export const INVITATION_PARAM: SCHEMA = {
   invitation_code: {
@@ -138,8 +171,10 @@ export const INVITATION_PARAM: SCHEMA = {
 ### `index.ts`
 ```typescript
 import { Hono, ValidationTargets } from 'hono';
+import { HTTPException } from 'hono/http-exception';
 import { validator } from 'hono/validator';
 import { getSchemaErrors } from 'ivl';
+import type { SCHEMA, CHECKABLE_OBJECT } from 'ivl';
 import { LOGIN_SCHEMA, REGISTER_SCHEMA, INVITE_REGISTER_SCHEMA, INVITATION_PARAM } from './rules.ts';
 
 // Wrapper for hono validator middleware

package/lib/core.d.ts

@@ -0,0 +1,86 @@
+import type { RULES, RULES_SYNC, SCHEMA, SCHEMA_SYNC, SCHEMA_OPTIONS, CHECKABLE_OBJECT, CHECKED_SCHEMA, CHECKED_SCHEMA_SYNC, RULES_KIND, SCHEMA_KIND, MAYBE_ASYNC } from './types';
+/**
+ * Detect if a function is async or not
+ *
+ * @param {unknown} fn the function to inspect
+ * @returns {boolean} true if `fn` is declared with the `async` keyword, otherwise false
+ */
+export declare const isAsyncFunction: (fn: unknown) => fn is (...args: never[]) => Promise<unknown>;
+/**
+ * Detect if a RULES object has any async rules in it
+ *
+ * @param {RULES|RULES[]} rules a rules object
+ * @returns {boolean} true if any of the rules is an async function otherwise false
+ */
+export declare const hasAsyncFunction: (rules: {
+    [key: string]: unknown;
+} | {
+    [key: string]: unknown;
+}[]) => boolean;
+/**
+ * Check the input against all provided validation rules asynchronously
+ *
+ * @param {V} value the value to check
+ * @param {RULES<V>} 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 {Promise<string[]>} a list of rule names which failed validation
+ */
+export declare const getValueErrorsAsync: <V>(value: V, rules: RULES<V>, ...overload: unknown[]) => Promise<string[]>;
+/**
+ * Check a schema against all provided validation rules asynchronously
+ *
+ * @param {CHECKABLE_OBJECT} object_to_check object to be validated
+ * @param {S} 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<S>} an object containing keys and their respective lists of failed rule names
+ */
+export declare const getSchemaErrorsAsync: <S extends SCHEMA>(object_to_check: CHECKABLE_OBJECT, schema: S, options?: SCHEMA_OPTIONS, ...overload: unknown[]) => CHECKED_SCHEMA<S>;
+/**
+ * Check the input against all provided validation rules synchronously
+ *
+ * @param {V} value the value to check
+ * @param {RULES_SYNC<V>} 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
+ */
+export declare const getValueErrorsSync: <V>(value: V, rules: RULES_SYNC<V>, ...overload: unknown[]) => string[];
+/**
+ * Check a schema against all provided validation rules synchronously
+ *
+ * @param {CHECKABLE_OBJECT} object object to be validated
+ * @param {S} 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_SYNC<S>} an object containing keys and their respective lists of failed rule names
+ */
+export declare const getSchemaErrorsSync: <S extends SCHEMA_SYNC>(object: CHECKABLE_OBJECT, schema: S, options?: SCHEMA_OPTIONS, ...overload: unknown[]) => CHECKED_SCHEMA_SYNC<S>;
+/**
+ * Check the input against all provided validation rules, choosing the sync or async
+ * implementation based on whether any rule is an `async` function.
+ *
+ * The return type is inferred from the rules: all-sync rules yield `string[]`,
+ * any `async` rule yields `Promise<string[]>`. Rules whose return type is declared
+ * as `boolean | Promise<boolean>` (e.g. annotated as `RULE`) yield the union.
+ *
+ * @param {V} value the value to check
+ * @param {R} 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 {Promise<string[]>|string[]} a list of rule names which failed validation
+ */
+export declare const getValueErrors: <V, R extends RULES<V>>(value: V, rules: R, ...overload: unknown[]) => MAYBE_ASYNC<RULES_KIND<R>, string[]>;
+/**
+ * Check a schema against all provided validation rules, choosing the sync or async
+ * implementation based on whether any rule is an `async` function.
+ *
+ * The return type is inferred from the schema: all-sync rules yield the result object
+ * directly, any `async` rule yields a `Promise` of it. Rules whose return type is declared
+ * as `boolean | Promise<boolean>` (e.g. a schema annotated as `SCHEMA`) yield the union.
+ *
+ * @param {CHECKABLE_OBJECT} object object to be validated
+ * @param {S} 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<S>|CHECKED_SCHEMA_SYNC<S>} an object containing keys and their respective lists of failed rule names
+ */
+export declare const getSchemaErrors: <S extends SCHEMA>(object: CHECKABLE_OBJECT, schema: S, options?: SCHEMA_OPTIONS, ...overload: unknown[]) => MAYBE_ASYNC<SCHEMA_KIND<S>, CHECKED_SCHEMA_SYNC<S>>;

package/lib/helpers/index.d.ts

@@ -1,21 +1,2 @@
-// Generated by dts-bundle-generator v9.5.1
-
-export type RULE_SYNC = (value: unknown, ...overload: unknown[]) => boolean;
-export type RULE = (value: unknown, ...overload: unknown[]) => boolean | Promise<boolean>;
-export type RULES = {
-	[index: string]: RULE;
-};
-export declare const isType: (type: "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function") => RULE_SYNC;
-export declare const matchesRegex: (regex: RegExp) => RULE_SYNC;
-export declare const max: (max_value?: number) => RULE_SYNC;
-export declare const min: (min_value?: number) => RULE_SYNC;
-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 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) => {};
-
-export {};
+export * from './rules';
+export * from './schema';

package/lib/helpers/index.js

@@ -1 +1 @@
-var u=(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),m=(n=1/0)=>(e)=>typeof e==="number"&&e<=n,y=(n=-1/0)=>(e)=>typeof e==="number"&&e>=n,f=(n=1/0)=>(e)=>u(e)&&e.length<=n,w=(n=0)=>(e)=>u(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(e,...t)))).some((o)=>o),h=(n=[])=>(e,...t)=>n.map((o)=>o(e,...t)).some((o)=>o);var l=(n)=>Object.entries(n).reduce((e,[t,o])=>({...e,[t]:(r,...s)=>typeof r==="undefined"?!0:o(r,...s)}),{}),x=(n,e)=>Object.entries(e).reduce((t,[o,r])=>({...t,[o]:(s,...p)=>r(n(s),...p)}),{});export{a as stringBetween,x as preprocess,L as numberBetween,w as minLength,y as min,f as maxLength,m as max,i as matchesRegex,c as isType,l as allowUndefined,h as acceptAnySync,g as acceptAnyAsync};
+var S=(n)=>typeof n==="string"||n!==null&&typeof n==="object"&&("length"in n)&&typeof n.length==="number",u=(n)=>(e)=>typeof e===n,c=(n)=>(e)=>typeof e==="string"&&n.test(e),C=(n=1/0)=>(e)=>typeof e==="number"&&e<=n,a=(n=-1/0)=>(e)=>typeof e==="number"&&e>=n,R=(n=1/0)=>(e)=>S(e)&&e.length<=n,_=(n=0)=>(e)=>S(e)&&e.length>=n,p=(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,m=(n=[])=>async(e,...t)=>(await Promise.all(n.map((r)=>r(e,...t)))).some((r)=>r),y=(n=[])=>(e,...t)=>n.map((r)=>r(e,...t)).some((r)=>r);var i=(n)=>typeof n==="function"&&n.constructor.name==="AsyncFunction";var N=(n)=>Object.entries(n).reduce((e,[t,r])=>{if(i(r))return{...e,[t]:async(o,...s)=>typeof o>"u"?!0:r(o,...s)};return{...e,[t]:(o,...s)=>typeof o>"u"?!0:r(o,...s)}},{}),O=(n,e)=>Object.entries(e).reduce((t,[r,o])=>{if(i(o))return{...t,[r]:async(s,...E)=>o(n(s),...E)};return{...t,[r]:(s,...E)=>o(n(s),...E)}},{});export{m as acceptAnyAsync,y as acceptAnySync,N as allowUndefined,u as isType,c as matchesRegex,C as max,R as maxLength,a as min,_ as minLength,l as numberBetween,O as preprocess,p as stringBetween};

package/lib/helpers/rules.d.ts

@@ -0,0 +1,14 @@
+import type { RULE, RULE_SYNC } from '../types';
+export type TYPEOF_RESULT = "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function";
+export declare const isType: (type: TYPEOF_RESULT) => RULE_SYNC;
+export declare const matchesRegex: (regex: RegExp) => RULE_SYNC;
+export declare const max: (max_value?: number) => RULE_SYNC;
+export declare const min: (min_value?: number) => RULE_SYNC;
+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;
+/** Passes if *any* of the given rules passes. Always async. */
+export declare const acceptAnyAsync: <V = unknown, O extends unknown[] = unknown[]>(rules?: RULE<V, O>[]) => RULE<V, O>;
+/** Passes if *any* of the given rules passes. All rules must be synchronous. */
+export declare const acceptAnySync: <V = unknown, O extends unknown[] = unknown[]>(rules?: RULE_SYNC<V, O>[]) => RULE_SYNC<V, O>;

package/lib/helpers/schema.d.ts

@@ -0,0 +1,23 @@
+import type { RULES } from '../types';
+/**
+ * Re-declares each rule so that the parameters of the returned rule are `V` instead of the
+ * original rule's parameters, while keeping the original return type (sync stays sync,
+ * async stays async).
+ */
+type REWRAPPED<R extends RULES<never>, V> = {
+    [K in keyof R]: R[K] extends (value: never, ...overload: infer O) => infer Ret ? (value: V, ...overload: O) => Ret : never;
+};
+/**
+ * Wraps every rule so that an `undefined` value always passes.
+ * Sync rules stay sync and async rules stay async, so `getValueErrors`/`getSchemaErrors`
+ * still pick the correct execution path.
+ */
+export declare const allowUndefined: <R extends RULES>(rules: R) => R;
+/**
+ * Wraps every rule so that the value is passed through `fn` before being validated.
+ * The rules may be typed against the *output* of `fn`; the returned rules accept `unknown`.
+ * Sync rules stay sync and async rules stay async, so `getValueErrors`/`getSchemaErrors`
+ * still pick the correct execution path.
+ */
+export declare const preprocess: <V, R extends RULES<V>>(fn: (value: unknown) => V, rules: R) => REWRAPPED<R, unknown>;
+export {};

package/lib/index.d.ts

@@ -1,94 +1,2 @@
-// Generated by dts-bundle-generator v9.5.1
-
-export type RULE_SYNC = (value: unknown, ...overload: unknown[]) => boolean;
-export type RULE = (value: unknown, ...overload: unknown[]) => boolean | Promise<boolean>;
-export type RULES_SYNC = {
-	[index: string]: RULE_SYNC;
-};
-export type RULES = {
-	[index: string]: RULE;
-};
-export type SCHEMA_SYNC = {
-	[index: string]: RULES_SYNC | RULES_SYNC[];
-};
-export type SCHEMA = {
-	[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 CHECKABLE_OBJECT = {
-	[index: string]: unknown;
-};
-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>|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> | Record<string, RULE>[]) => boolean;
-/**
- * Check the input against all provided validation rules asynchronously
- *
- * @param {unknown} value the value to check
- * @param {RULES} 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
- */
-export declare const getValueErrorsAsync: (value: unknown, rules: RULES, ...overload: unknown[]) => Promise<string[]>;
-/**
- * Check a schema against all provided validation rules asynchronously
- *
- * @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<T>} an object containing keys and their respective lists of failed rule names
- */
-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
- * @param {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
- */
-export declare const getValueErrorsSync: (value: unknown, rules: RULES_SYNC, ...overload: unknown[]) => string[];
-/**
-* Check a schema against all provided validation rules asynchronously
-*
-* @param {CHECKABLE_OBJECT} object 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_SYNC<T>} an object containing keys and their respective lists of failed rule names
-*/
-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 {Promise<string[]>|string[]} a list of rule names which failed validation
- */
-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_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: <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 {};
+export * from './core';
+export * from './types';

package/lib/index.js

@@ -1 +1 @@
-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};
+var A={strict:!1};var u=(n)=>typeof n==="function"&&n.constructor.name==="AsyncFunction",N=(n)=>{if(Array.isArray(n))return n.some((s)=>Object.values(s).some(u));return Object.values(n).some(u)},a=async(n,s,...S)=>{let r={};return Object.entries(s).forEach(([t,E])=>{r[t]=Promise.resolve(!1).then(()=>E(n,...S)).then((e)=>r[t]=e).catch(()=>r[t]=!1)}),await Promise.allSettled(Object.values(r)),Object.entries(r).reduce((t,[E,e])=>e?t:[...t,E],[])},O=async(n,s,S=A,...r)=>{let t={},E=[];if(Object.entries(s).forEach(([e,C])=>{let i;if(Array.isArray(C))i=Promise.allSettled(C.map((o)=>a(n[e],o,...r))).then((o)=>{let l=o.map((c)=>{if(c.status==="fulfilled")return c.value;return["Unknown error occurred"]});if(l.some((c)=>!c.length))t[e]=[];else t[e]=l}).catch((o)=>{if(o instanceof Error)t[e]=[o.message];else t[e]=["Unknown error occurred"]});else i=a(n[e],C,...r).then((o)=>{t[e]=o}).catch((o)=>{t[e]=[o instanceof Error?o.message:"Unknown error occurred"]});E.push(i)}),S.strict){let e=Object.keys(n),C=new Set(Object.keys(s));e.filter((o)=>!C.has(o)).forEach((o)=>{t[o]=["Key not allowed"]})}return await Promise.allSettled(E),t},_=(n,s,...S)=>Object.entries(s).reduce((r,[t,E])=>{try{return E(n,...S)?r:[...r,t]}catch(e){return[...r,t]}},[]),H=(n,s,S=A,...r)=>{let t=Object.entries(s).reduce((E,[e,C])=>{if(Array.isArray(C)){let i=C.map((o)=>_(n[e],o,...r));if(i.some((o)=>!o.length))return{...E,[e]:[]};return{...E,[e]:i}}return{...E,[e]:_(n[e],C,...r)}},{});if(S.strict){let E=Object.keys(n),e=new Set(Object.keys(s));E.filter((i)=>!e.has(i)).forEach((i)=>{t[i]=["Key not allowed"]})}return t},M=(n,s,...S)=>N(s)?a(n,s,...S):_(n,s,...S),m=(n)=>Object.values(n).some(N),R=(n,s,S=A,...r)=>m(s)?O(n,s,S,...r):H(n,s,S,...r);export{R as getSchemaErrors,O as getSchemaErrorsAsync,H as getSchemaErrorsSync,M as getValueErrors,a as getValueErrorsAsync,_ as getValueErrorsSync,N as hasAsyncFunction,u as isAsyncFunction};

package/lib/patterns/index.d.ts

@@ -1,14 +1 @@
-// Generated by dts-bundle-generator v9.5.1
-
-export declare const EMAIL_PATTERN: RegExp;
-export declare const MYSQL_TIMESTAMP_PATTERN: RegExp;
-export declare const URL_PATTERN: RegExp;
-export declare const ISO_8601_DATETIME_PATTERN_STRICT: RegExp;
-export declare const ISO_8601_DATETIME_PATTERN: RegExp;
-export declare const ISO_8601_TIME_PATTERN: RegExp;
-export declare const CONTAINS_LOWERCASE_CHARACTER_PATTERN: RegExp;
-export declare const CONTAINS_UPPERCASE_CHARACTER_PATTERN: RegExp;
-export declare const CONTAINS_DIGIT_CHARACTER_PATTERN: RegExp;
-export declare const CONTAINS_SYMBOL_CHARACTER_PATTERN: RegExp;
-
-export {};
+export * from './patterns';

package/lib/patterns/index.js

@@ -1 +1 @@
-var x=/^[\w.%+-]+@[\w.-]+\.[a-zA-Z]{1,}$/,c=/^(\d{4})-(\d{2})-(\d{2}) (\d{2}):(\d{2}):(\d{2})$/,d=/^(https?:\/\/)?([^\s$.?#].[^\s]*)\.[a-z]{2,}(\/[^ \t\r\n\v\f]*)?$/i,f=/^(\d{4}-[01]\d-[0-3]\dT[0-2]\d:[0-5]\d:[0-5]\d(?:\.\d+)?(?:[+-][0-2]\d:[0-5]\d|Z)?)$/,j=/^(\d{4}-[01]\d-[0-3]\dT[0-2]\d:[0-5]\d(?::[0-5]\d(?:\.\d+)?)?)$/,k=/^(2[0-3]|[01][0-9]):([0-5][0-9]):([0-5][0-9])(Z|[+-](?:2[0-3]|[01][0-9]):([0-5][0-9]))?$/,l=/[a-z]/,m=/[A-Z]/,p=/\d/,q=/[^\w\s]/;export{d as URL_PATTERN,c as MYSQL_TIMESTAMP_PATTERN,k as ISO_8601_TIME_PATTERN,f as ISO_8601_DATETIME_PATTERN_STRICT,j as ISO_8601_DATETIME_PATTERN,x as EMAIL_PATTERN,m as CONTAINS_UPPERCASE_CHARACTER_PATTERN,q as CONTAINS_SYMBOL_CHARACTER_PATTERN,l as CONTAINS_LOWERCASE_CHARACTER_PATTERN,p as CONTAINS_DIGIT_CHARACTER_PATTERN};
+var T=/^[\w.%+-]+@[\w.-]+\.[a-zA-Z]{1,}$/,A=/^(\d{4})-(\d{2})-(\d{2}) (\d{2}):(\d{2}):(\d{2})$/,_=/^(https?:\/\/)?([^\s$.?#].[^\s]*)\.[a-z]{2,}(\/[^ \t\r\n\v\f]*)?$/i,E=/^(\d{4}-[01]\d-[0-3]\dT[0-2]\d:[0-5]\d:[0-5]\d(?:\.\d+)?(?:[+-][0-2]\d:[0-5]\d|Z)?)$/,t=/^(\d{4}-[01]\d-[0-3]\dT[0-2]\d:[0-5]\d(?::[0-5]\d(?:\.\d+)?)?)$/,d=/^(2[0-3]|[01][0-9]):([0-5][0-9]):([0-5][0-9])(Z|[+-](?:2[0-3]|[01][0-9]):([0-5][0-9]))?$/,o=/[a-z]/,R=/[A-Z]/,N=/\d/,C=/[^\w\s]/;export{N as CONTAINS_DIGIT_CHARACTER_PATTERN,o as CONTAINS_LOWERCASE_CHARACTER_PATTERN,C as CONTAINS_SYMBOL_CHARACTER_PATTERN,R as CONTAINS_UPPERCASE_CHARACTER_PATTERN,T as EMAIL_PATTERN,t as ISO_8601_DATETIME_PATTERN,E as ISO_8601_DATETIME_PATTERN_STRICT,d as ISO_8601_TIME_PATTERN,A as MYSQL_TIMESTAMP_PATTERN,_ as URL_PATTERN};

package/lib/patterns/patterns.d.ts

@@ -0,0 +1,10 @@
+export declare const EMAIL_PATTERN: RegExp;
+export declare const MYSQL_TIMESTAMP_PATTERN: RegExp;
+export declare const URL_PATTERN: RegExp;
+export declare const ISO_8601_DATETIME_PATTERN_STRICT: RegExp;
+export declare const ISO_8601_DATETIME_PATTERN: RegExp;
+export declare const ISO_8601_TIME_PATTERN: RegExp;
+export declare const CONTAINS_LOWERCASE_CHARACTER_PATTERN: RegExp;
+export declare const CONTAINS_UPPERCASE_CHARACTER_PATTERN: RegExp;
+export declare const CONTAINS_DIGIT_CHARACTER_PATTERN: RegExp;
+export declare const CONTAINS_SYMBOL_CHARACTER_PATTERN: RegExp;

package/lib/types.d.ts

@@ -0,0 +1,82 @@
+/**
+ * A synchronous validation rule.
+ *
+ * @template V type of the value being validated (defaults to `unknown`)
+ * @template O tuple type of any extra "overload" arguments passed through by the caller
+ */
+export type RULE_SYNC<V = unknown, O extends unknown[] = unknown[]> = (value: V, ...overload: O) => boolean;
+/**
+ * An asynchronous validation rule.
+ *
+ * @template V type of the value being validated (defaults to `unknown`)
+ * @template O tuple type of any extra "overload" arguments passed through by the caller
+ */
+export type RULE_ASYNC<V = unknown, O extends unknown[] = unknown[]> = (value: V, ...overload: O) => Promise<boolean>;
+/**
+ * A validation rule which may be either synchronous or asynchronous.
+ *
+ * @template V type of the value being validated (defaults to `unknown`)
+ * @template O tuple type of any extra "overload" arguments passed through by the caller
+ */
+export type RULE<V = unknown, O extends unknown[] = unknown[]> = (value: V, ...overload: O) => boolean | Promise<boolean>;
+/** A named set of synchronous rules. Keys are the error messages returned on failure. */
+export type RULES_SYNC<V = unknown, O extends unknown[] = unknown[]> = {
+    [rule_name: string]: RULE_SYNC<V, O>;
+};
+/** A named set of rules, any of which may be asynchronous. Keys are the error messages returned on failure. */
+export type RULES<V = unknown, O extends unknown[] = unknown[]> = {
+    [rule_name: string]: RULE<V, O>;
+};
+/**
+ * Maps object keys to a rule set, or to an array of alternative rule sets
+ * (the value passes if it satisfies *any* of the alternatives).
+ */
+export type SCHEMA_SYNC = {
+    [key: string]: RULES_SYNC | RULES_SYNC[];
+};
+export type SCHEMA = {
+    [key: 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 CHECKABLE_OBJECT = {
+    [key: string]: unknown;
+};
+/**
+ * The result of checking a single schema entry.
+ * A plain rule set yields `string[]`; an array of alternative rule sets yields `string[][]`
+ * (one error list per alternative, or `[]` if any alternative passed).
+ */
+export type CHECKED_RULES<R> = R extends readonly unknown[] ? string[][] : string[];
+/**
+ * The result of checking a schema: one entry per schema key, with a shape that
+ * depends on that key's rule set. When `strict: true` is used, keys not present in
+ * the schema may also appear with the value `['Key not allowed']`.
+ */
+export type CHECKED_SCHEMA_SYNC<S extends SCHEMA = SCHEMA> = {
+    [K in keyof S]: CHECKED_RULES<S[K]>;
+} & {
+    [extra_key: string]: string[] | string[][];
+};
+export type CHECKED_SCHEMA<S extends SCHEMA = SCHEMA> = Promise<CHECKED_SCHEMA_SYNC<S>>;
+/**
+ * Classifies a rule by its declared return type:
+ * - `'sync'`   – returns `boolean`
+ * - `'async'`  – returns `Promise<boolean>`
+ * - `'either'` – declared as returning `boolean | Promise<boolean>` (e.g. annotated as `RULE`),
+ *                so it can't be determined statically
+ */
+export type RULE_KIND<R> = R extends (...args: never[]) => infer Ret ? [Ret] extends [boolean] ? 'sync' : [Ret] extends [Promise<boolean>] ? 'async' : 'either' : never;
+/** Union of the kinds of every rule in a rule set (or in an array of rule sets). */
+export type RULES_KIND<R> = R extends readonly (infer E)[] ? RULES_KIND<E> : R extends object ? RULE_KIND<R[keyof R]> : never;
+/** Union of the kinds of every rule in a schema. */
+export type SCHEMA_KIND<S> = RULES_KIND<S[keyof S]>;
+/**
+ * Wraps a result type according to the kinds found in a rule set / schema:
+ * any definitely-async rule => `Promise<X>`; all sync => `X`; otherwise `X | Promise<X>`.
+ */
+export type MAYBE_ASYNC<K, X> = 'async' extends K ? Promise<X> : 'either' extends K ? X | Promise<X> : X;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ivl",
-  "version": "0.3.1",
+  "version": "0.4.1",
   "author": {
     "name": "Oskar Voorel",
     "email": "oskar@voorel.com"
@@ -11,12 +11,12 @@
   },
   "main": "lib/index.js",
   "devDependencies": {
-    "@types/bun": "latest",
-    "bun-plugin-dts": "^0.2.1",
-    "mitata": "^0.1.11",
-    "typescript": "^5.2.2",
-    "yup": "^1.4.0",
-    "zod": "^3.23.8"
+    "@types/bun": "^1.4.0",
+    "mitata": "^1.0.34",
+    "tsc-alias": "^1.9.2",
+    "typescript": "^7.0.2",
+    "yup": "^1.7.1",
+    "zod": "^4.5.2"
   },
   "exports": {
     ".": {
@@ -48,10 +48,13 @@
   ],
   "license": "MIT",
   "scripts": {
-    "build": "rm -rf ./lib && bun run build.mjs",
+    "build": "rm -rf ./lib && bun run build.mjs && tsc -p tsconfig.build.json && tsc-alias -p tsconfig.build.json",
     "prepublishOnly": "bun run build",
-    "benchmark": "bun run ./benchmark/index.ts"
+    "benchmark": "bun run ./benchmark/index.ts",
+    "typecheck": "tsc --noEmit -p tsconfig.test.json",
+    "test": "bun test && bun run typecheck",
+    "release": "bun run ./scripts/release.ts"
   },
-  "sideEffects": "false",
+  "sideEffects": false,
   "types": "lib/index.d.ts"
 }