@lucania/schema 1.0.8 → 2.0.1

package/build/schema/AnySchema.d.ts

@@ -0,0 +1,8 @@
+import { DefaultValue } from "../typing/toolbox";
+import { ValidationPass } from "../error/ValidationPass";
+import { BaseSchema } from "./BaseSchema";
+export declare class AnySchema<Required extends boolean, Default extends DefaultValue<any>> extends BaseSchema<any, any, Required, Default> {
+    constructor(required: Required, defaultValue: Default);
+    convert(value: any, pass: ValidationPass): any;
+    getJsonSchema(): object;
+}

package/build/schema/ArraySchema.d.ts

@@ -0,0 +1,13 @@
+import { ValidationPass } from "../error/ValidationPass";
+import { BaseSchemaAny } from "../typing/extended";
+import type { DefaultValue, ModelValue, SourceValue } from "../typing/toolbox";
+import { BaseSchema } from "./BaseSchema";
+export type ArraySource<Subschema extends BaseSchemaAny> = (Subschema extends BaseSchema<infer Source, any, infer Required, infer Default> ? (SourceValue<Source, Required, Default>[]) : never);
+export type ArrayModel<Subschema extends BaseSchemaAny> = (Subschema extends BaseSchema<infer Source, infer Model, infer Required, infer Default> ? (ModelValue<Source, Model, Required, Default>[]) : never);
+export declare class ArraySchema<Subschema extends BaseSchemaAny, Required extends boolean, Default extends DefaultValue<ArraySource<Subschema>>> extends BaseSchema<ArraySource<Subschema>, ArrayModel<Subschema>, Required, Default> {
+    readonly subschema: Subschema;
+    constructor(subschema: Subschema, required: Required, defaultValue: Default);
+    validate(source: SourceValue<ArraySource<Subschema>, Required, Default>, pass?: ValidationPass): ModelValue<ArraySource<Subschema>, ArrayModel<Subschema>, Required, Default>;
+    convert(value: ArraySource<Subschema>, pass: ValidationPass): ArrayModel<Subschema>;
+    getJsonSchema(): object;
+}

package/build/schema/BaseSchema.d.ts

@@ -0,0 +1,32 @@
+import { ValidationPass } from "../error/ValidationPass";
+import type { AdditionalValidationPasses, AdditionalValidator, AdditionalValidatorAfterType, AdditionalValidatorBeforeType, DefaultValue, EnsureValidator, ModelValue, SourceValue } from "../typing/toolbox";
+export declare abstract class BaseSchema<Source, Model, Required extends boolean, Default extends DefaultValue<Source>> {
+    readonly type: string;
+    protected readonly _required: Required;
+    protected readonly _default: Default;
+    protected readonly _additionalValidationPasses: AdditionalValidationPasses<Source, Model>;
+    constructor(type: string, required: Required, defaultValue: Default, additionalValidationPasses?: AdditionalValidationPasses<Source, Model>);
+    validate(source: SourceValue<Source, Required, Default>, pass?: ValidationPass): ModelValue<Source, Model, Required, Default>;
+    abstract convert(value: Source, pass: ValidationPass): Model;
+    custom(additionalValidator: AdditionalValidator<SourceValue<Source, Required, Default>>, type: AdditionalValidatorBeforeType): this;
+    custom(additionalValidator: AdditionalValidator<Model>, type: AdditionalValidatorAfterType): this;
+    custom(additionalValidator: AdditionalValidator<Model>): this;
+    ensure(ensureValidator: EnsureValidator<Model>, message?: string): this;
+    hasDefault(): boolean;
+    isDefaultRuntimeEvaluated(): this is {
+        _default: Function;
+    };
+    getDefault(pass: ValidationPass): Source;
+    protected _getValueDisplay(value: Model): string;
+    abstract getJsonSchema(): object;
+    protected _getJsonSchemaDescription(): string;
+    protected _ensurePass(source: SourceValue<Source, Required, Default>, pass?: ValidationPass): ValidationPass;
+    private _executeAdditionalValidator;
+    /**
+     * Checks to see if a value is present. (Not null or undefined)
+     * @param value The value to check the presence of.
+     * @returns true if value is not null or undefined, false otherwise.
+     */
+    static isPresent(value: any): value is Exclude<Exclude<any, null>, undefined>;
+    static getType(value: any): any;
+}

package/build/schema/BooleanSchema.d.ts

@@ -0,0 +1,9 @@
+import { DefaultValue } from "../typing/toolbox";
+import { ValidationPass } from "../error/ValidationPass";
+import { BaseSchema } from "./BaseSchema";
+export type BooleanSource = boolean | number | string | null | undefined;
+export declare class BooleanSchema<Required extends boolean, Default extends DefaultValue<BooleanSource>> extends BaseSchema<BooleanSource, boolean, Required, Default> {
+    constructor(required: Required, defaultValue: Default);
+    convert(value: BooleanSource, pass: ValidationPass): boolean;
+    getJsonSchema(): object;
+}

package/build/schema/DateSchema.d.ts

@@ -0,0 +1,22 @@
+import { DefaultValue } from "../typing/toolbox";
+import { ValidationPass } from "../error/ValidationPass";
+import { BaseSchema } from "./BaseSchema";
+type StandardDate = globalThis.Date;
+declare const StandardDate: DateConstructor;
+export type DateSource = string | number | StandardDate;
+export declare class DateSchema<Required extends boolean, Default extends DefaultValue<DateSource>> extends BaseSchema<DateSource, StandardDate, Required, Default> {
+    constructor(required: Required, defaultValue: Default);
+    convert(value: DateSource, pass: ValidationPass): StandardDate;
+    before(date: Date, message?: string): this;
+    after(date: Date, message?: string): this;
+    /**
+     * @param duration milliseconds
+     */
+    moreThanAgo(duration: number, message?: string): this;
+    /**
+    * @param duration milliseconds
+    */
+    lessThanAgo(duration: number, message?: string): this;
+    getJsonSchema(): object;
+}
+export {};

package/build/schema/DynamicObjectSchema.d.ts

@@ -0,0 +1,17 @@
+import type { DefaultValue, ModelValue, SourceValue } from "../typing/toolbox";
+import { ValidationPass } from "../error/ValidationPass";
+import { BaseSchemaAny } from "../typing/extended";
+import { BaseSchema } from "./BaseSchema";
+export type DynamicObjectSource<Subschema extends BaseSchemaAny> = ({
+    [Key: string]: (Subschema extends BaseSchema<infer Source, any, infer Required, infer Default> ? (SourceValue<Source, Required, Default>) : never);
+});
+export type DynamicObjectModel<Subschema extends BaseSchemaAny> = ({
+    [Key: string]: (Subschema extends BaseSchema<infer Source, infer Model, infer Required, infer Default> ? (ModelValue<Source, Model, Required, Default>) : never);
+});
+export declare class DynamicObjectSchema<Subschema extends BaseSchemaAny, Required extends boolean, Default extends DefaultValue<DynamicObjectSource<Subschema>>> extends BaseSchema<DynamicObjectSource<Subschema>, DynamicObjectModel<Subschema>, Required, Default> {
+    readonly subschema: Subschema;
+    constructor(subschema: Subschema, required: Required, defaultValue: Default);
+    validate(source: SourceValue<DynamicObjectSource<Subschema>, Required, Default>, pass?: ValidationPass): ModelValue<DynamicObjectSource<Subschema>, DynamicObjectModel<Subschema>, Required, Default>;
+    convert(source: DynamicObjectSource<Subschema>, pass: ValidationPass): DynamicObjectModel<Subschema>;
+    getJsonSchema(): object;
+}

package/build/schema/EnumerationSchema.d.ts

@@ -0,0 +1,10 @@
+import { DefaultValue, ModelValue, SourceValue } from "../typing/toolbox";
+import { ValidationPass } from "../error/ValidationPass";
+import { BaseSchema } from "./BaseSchema";
+export declare class EnumerationSchema<Members extends string[], Required extends boolean, Default extends DefaultValue<Members[number]>> extends BaseSchema<Members[number], Members[number], Required, Default> {
+    readonly members: Members;
+    constructor(members: Members, required: Required, defaultValue: Default);
+    validate(source: SourceValue<Members[number], Required, Default>, pass?: ValidationPass): ModelValue<Members[number], Members[number], Required, Default>;
+    convert(value: Members[number], pass: ValidationPass): Members[number];
+    getJsonSchema(): object;
+}

package/build/schema/NumberSchema.d.ts

@@ -0,0 +1,15 @@
+import { DefaultValue } from "../typing/toolbox";
+import { ValidationPass } from "../error/ValidationPass";
+import { BaseSchema } from "./BaseSchema";
+export type NumberSource = number | bigint | string | boolean | null | undefined | Date;
+export declare class NumberSchema<Required extends boolean, Default extends DefaultValue<NumberSource>> extends BaseSchema<NumberSource, number, Required, Default> {
+    constructor(required: Required, defaultValue: Default);
+    convert(value: NumberSource, pass: ValidationPass): number;
+    min(minimum: number, message?: string): this;
+    max(maximum: number, message?: string): this;
+    clamp(minimum: number, maximum: number): this;
+    clamp(minimum: number, maximum: number, message: string): this;
+    clamp(minimum: number, maximum: number, tooShortMessage: string, tooLongMessage: string): this;
+    validNumber(notANumber?: boolean, message?: string): this;
+    getJsonSchema(): object;
+}

package/build/schema/ObjectSchema.d.ts

@@ -0,0 +1,25 @@
+import type { DefaultValue, Merge, ModelRequirement, ModelValue, SourceRequirement, SourceValue } from "../typing/toolbox";
+import { ValidationPass } from "../error/ValidationPass";
+import { BaseSchemaAny } from "../typing/extended";
+import { BaseSchema } from "./BaseSchema";
+export type ObjectSubschema = {
+    [Key: string]: BaseSchemaAny;
+};
+export type ObjectSource<Subschema extends ObjectSubschema> = (Merge<{
+    [Key in keyof Subschema as SourceRequirement<Subschema[Key]> extends true ? Key : never]: (Subschema[Key] extends BaseSchema<infer Source, any, infer Required, infer Default> ? (SourceValue<Source, Required, Default>) : never);
+}, {
+    [Key in keyof Subschema as SourceRequirement<Subschema[Key]> extends false ? Key : never]?: (Subschema[Key] extends BaseSchema<infer Source, any, infer Required, infer Default> ? (SourceValue<Source, Required, Default>) : never);
+}>);
+export type ObjectModel<Subschema extends ObjectSubschema> = (Merge<{
+    [Key in keyof Subschema as ModelRequirement<Subschema[Key]> extends true ? Key : never]: (Subschema[Key] extends BaseSchema<infer Source, infer Model, infer Required, infer Default> ? (ModelValue<Source, Model, Required, Default>) : never);
+}, {
+    [Key in keyof Subschema as ModelRequirement<Subschema[Key]> extends false ? Key : never]?: (Subschema[Key] extends BaseSchema<infer Source, infer Model, infer Required, infer Default> ? (ModelValue<Source, Model, Required, Default>) : never);
+}>);
+export declare class ObjectSchema<Subschema extends ObjectSubschema, Required extends boolean, Default extends DefaultValue<ObjectSource<Subschema>>> extends BaseSchema<ObjectSource<Subschema>, ObjectModel<Subschema>, Required, Default> {
+    readonly subschema: Subschema;
+    constructor(subschema: Subschema, required: Required, defaultValue: Default);
+    validate(source: SourceValue<ObjectSource<Subschema>, Required, Default>, pass?: ValidationPass): ModelValue<ObjectSource<Subschema>, ObjectModel<Subschema>, Required, Default>;
+    convert(value: ObjectSource<Subschema>, pass: ValidationPass): ObjectModel<Subschema>;
+    extend<ExtensionSubschema extends ObjectSubschema, ExtensionDefault extends DefaultValue<ObjectSource<ExtensionSubschema>>>(schema: ObjectSchema<ExtensionSubschema, Required, ExtensionDefault>): ObjectSchema<Subschema & ExtensionSubschema, Required, any>;
+    getJsonSchema(): object;
+}

package/build/schema/OrSetSchema.d.ts

@@ -0,0 +1,17 @@
+import { ValidationPass } from "../error/ValidationPass";
+import { BaseSchemaAny } from "../typing/extended";
+import { DefaultValue, ModelValue, SourceValue } from "../typing/toolbox";
+import { BaseSchema } from "./BaseSchema";
+export type OrSetSchemaSource<MemberSchemas extends BaseSchemaAny[]> = {
+    [Key in keyof MemberSchemas]: (MemberSchemas[Key] extends BaseSchema<infer Source, any, infer Required, infer Default> ? (SourceValue<Source, Required, Default>) : never);
+}[number];
+export type OrSetSchemaModel<MemberSchemas extends BaseSchemaAny[]> = ({
+    [Key in keyof MemberSchemas]: (MemberSchemas[Key] extends BaseSchema<infer Source, infer Model, infer Required, infer Default> ? (ModelValue<Source, Model, Required, Default>) : never);
+})[number];
+export declare class OrSetSchema<MemberSchemas extends BaseSchemaAny[], Required extends boolean, Default extends DefaultValue<OrSetSchemaSource<MemberSchemas>>> extends BaseSchema<OrSetSchemaSource<MemberSchemas>, OrSetSchemaModel<MemberSchemas>, Required, Default> {
+    readonly schemas: MemberSchemas;
+    constructor(schemas: MemberSchemas, required: Required, defaultValue: Default);
+    validate(source: SourceValue<OrSetSchemaSource<MemberSchemas>, Required, Default>, pass?: ValidationPass): ModelValue<OrSetSchemaSource<MemberSchemas>, OrSetSchemaModel<MemberSchemas>, Required, Default>;
+    convert(value: OrSetSchemaSource<MemberSchemas>, pass: ValidationPass): OrSetSchemaModel<MemberSchemas>;
+    getJsonSchema(): object;
+}

package/build/schema/StringSchema.d.ts

@@ -0,0 +1,13 @@
+import { ValidationPass } from "../error/ValidationPass";
+import { AdditionalValidationPasses, DefaultValue } from "../typing/toolbox";
+import { BaseSchema } from "./BaseSchema";
+export type StringSource = string | number | boolean | null | undefined | Date;
+export declare class StringSchema<Required extends boolean, Default extends DefaultValue<StringSource>> extends BaseSchema<StringSource, string, Required, Default> {
+    constructor(required: Required, defaultValue: Default, additionalValidationPasses?: AdditionalValidationPasses<StringSource, string>);
+    convert(value: StringSource, pass: ValidationPass): string;
+    length(minimum: number, maximum: number): this;
+    length(minimum: number, maximum: number, message: string): this;
+    length(minimum: number, maximum: number, tooShortMessage: string, tooLongMessage: string): this;
+    regex(expression: RegExp, message?: string): this;
+    getJsonSchema(): object;
+}

package/build/typing/extended.d.ts

@@ -0,0 +1,3 @@
+import { BaseSchema } from "../schema/BaseSchema";
+import { DefaultValue } from "./toolbox";
+export type BaseSchemaAny = BaseSchema<any, any, boolean, DefaultValue<any>>;

package/build/typing/toolbox.d.ts

@@ -0,0 +1,37 @@
+import { ValidationPass } from "../error/ValidationPass";
+import { BaseSchema } from "../schema/BaseSchema";
+import { BaseSchemaAny } from "./extended";
+export type SourceRequirement<Layout extends BaseSchemaAny> = (Layout extends BaseSchema<any, any, infer Required, infer Default> ? (Required extends true ? (Default extends undefined ? true : false) : (false)) : never);
+export type SourceValue<Source, Required extends boolean, Default extends DefaultValue<Source>> = (Required extends true ? (undefined extends Default ? (Source) : (Source | undefined)) : Source | undefined);
+export type ModelRequirement<Layout extends BaseSchemaAny> = (Layout extends BaseSchema<any, any, infer Required, infer Default> ? (Required extends true ? (true) : (Default extends undefined ? false : true)) : never);
+export type ModelValue<Source, Model, Required extends boolean, Default extends DefaultValue<Source>> = (Required extends true ? Model : Default extends undefined ? Model | undefined : Model);
+export type DefaultValue<Type> = undefined | Type | ((pass: ValidationPass) => Type);
+export type TypedMembers<Members> = {
+    data: Members;
+};
+export type AdditionalValidatorBeforeType = ("beforeAll" | "beforeDefault" | "afterDefault");
+export type AdditionalValidatorAfterType = ("beforeConversion" | "afterConversion" | "afterAll");
+/**
+ * @note Types specifying when an additional validation pass is executed during the validation pipeline.
+ *  - beforeAll: Validator executed directly on user's input, before default value evaluation and type conversions.
+ *  - beforeDefault: Validator executed after "beforeAll" and right before default value evaluation.
+ *  - afterDefault: Validator executed directly after default value evaluation and before type conversions.
+ *  - beforeConversion: Validator executed after "afterDefault" and before type conversions.
+ *  - afterConversion: Validator executed directly after type conversion.
+ *  - afterAll: Validator executed after "afterConversion" and as the last task in the validation pipeline.
+ */
+export type AdditionalValidatorType = AdditionalValidatorBeforeType | AdditionalValidatorAfterType;
+export type AdditionalValidator<Type> = (data: Type, pass: ValidationPass) => Type;
+/**
+ * Represents a pass to ensure that your data meets a condition. Return true if your data is ensured to meet condition, false otherwise.
+ */
+export type EnsureValidator<Type> = (data: Type, pass: ValidationPass) => boolean;
+export type AdditionalValidationPasses<Source, Model> = {
+    beforeAll: AdditionalValidator<Source>[];
+    beforeDefault: AdditionalValidator<Source>[];
+    afterDefault: AdditionalValidator<Source>[];
+    beforeConversion: AdditionalValidator<Model>[];
+    afterConversion: AdditionalValidator<Model>[];
+    afterAll: AdditionalValidator<Model>[];
+};
+export type Merge<ObjectA, ObjectB> = (keyof ObjectA extends never ? ObjectB : keyof ObjectB extends never ? ObjectA : ObjectA & ObjectB);

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@lucania/schema",
-    "version": "1.0.8",
+    "version": "2.0.1",
     "description": "A schema module for compile-time and runtime type checking.",
     "main": "./build/index.js",
     "types": "./build/index.d.ts",
@@ -29,12 +29,12 @@
     },
     "homepage": "https://github.com/lucania-software/schema#readme",
     "devDependencies": {
-        "@babel/preset-env": "^7.22.9",
-        "@rollup/plugin-typescript": "^11.1.2",
-        "@types/node": "^20.4.2",
-        "nodemon": "^3.0.1",
-        "rollup": "^3.26.3",
-        "tslib": "^2.6.0",
-        "typescript": "^5.1.6"
+        "@babel/preset-env": "^7.23.5",
+        "@rollup/plugin-typescript": "^11.1.5",
+        "@types/node": "^20.10.4",
+        "nodemon": "^3.0.2",
+        "rollup": "^4.6.1",
+        "tslib": "^2.6.2",
+        "typescript": "^5.3.3"
     }
 }