@forgehive/schema 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 ForgeHive
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE. 

package/dist/index.d.ts

@@ -0,0 +1,133 @@
+import { z } from 'zod';
+export type SchemaType = z.ZodType<string | boolean | number | Date | string[] | boolean[] | number[] | Date[] | Record<string, string | number | boolean>> | z.ZodOptional<z.ZodType<string | boolean | number | Date | string[] | boolean[] | number[] | Date[] | Record<string, string | number | boolean>>>;
+type AllowedBaseTypes = 'string' | 'boolean' | 'number' | 'date' | 'stringRecord' | 'numberRecord' | 'booleanRecord' | 'mixedRecord';
+type ArrayTypes = z.ZodString | z.ZodBoolean | z.ZodNumber | z.ZodDate;
+type NumberValidations = {
+    min?: number;
+    max?: number;
+};
+type StringValidations = {
+    email?: boolean;
+    minLength?: number;
+    maxLength?: number;
+    regex?: string;
+};
+export type ShadowString = z.ZodString;
+export type ShadowBoolean = z.ZodBoolean;
+export type ShadowNumber = z.ZodNumber;
+export type ShadowDate = z.ZodDate;
+export type ShadowArray<T extends ArrayTypes> = z.ZodArray<T>;
+export type ShadowStringRecord = z.ZodRecord<z.ZodString, z.ZodString>;
+export type ShadowNumberRecord = z.ZodRecord<z.ZodString, z.ZodNumber>;
+export type ShadowBooleanRecord = z.ZodRecord<z.ZodString, z.ZodBoolean>;
+export type ShadowMixedRecord = z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
+export type InferShadowString = z.infer<ShadowString>;
+export type InferShadowBoolean = z.infer<ShadowBoolean>;
+export type InferShadowNumber = z.infer<ShadowNumber>;
+export type InferShadowDate = z.infer<ShadowDate>;
+export type InferShadowArray<T extends ArrayTypes> = z.infer<ShadowArray<T>>;
+export type InferShadowStringRecord = z.infer<ShadowStringRecord>;
+export type InferShadowNumberRecord = z.infer<ShadowNumberRecord>;
+export type InferShadowBooleanRecord = z.infer<ShadowBooleanRecord>;
+export type InferShadowMixedRecord = z.infer<ShadowMixedRecord>;
+export type InferSchema<S extends Schema<Record<string, SchemaType>>> = z.infer<S['schema']>;
+type BaseSchemaDescription = {
+    type: AllowedBaseTypes;
+    optional?: boolean;
+    validations?: NumberValidations | StringValidations;
+};
+type ArraySchemaDescription = {
+    type: 'array';
+    items: {
+        type: AllowedBaseTypes;
+    };
+    optional?: boolean;
+};
+export type SchemaDescription = Record<string, BaseSchemaDescription | ArraySchemaDescription>;
+export declare class Schema<T extends Record<string, z.ZodType<string | boolean | number | Date | string[] | boolean[] | number[] | Date[] | Record<string, string | number | boolean>> | z.ZodOptional<z.ZodType<string | boolean | number | Date | string[] | boolean[] | number[] | Date[] | Record<string, string | number | boolean>>>>> {
+    readonly schema: z.ZodObject<T>;
+    constructor(fields: T);
+    /**
+     * Creates a string schema
+     * @returns A string schema
+     */
+    static string(): ShadowString;
+    /**
+     * Creates a boolean schema
+     * @returns A boolean schema
+     */
+    static boolean(): ShadowBoolean;
+    /**
+     * Creates a number schema
+     * @returns A number schema
+     */
+    static number(): ShadowNumber;
+    /**
+     * Creates a date schema
+     * @returns A date schema
+     */
+    static date(): ShadowDate;
+    /**
+     * Creates a record schema with string keys and string values
+     * @returns A record schema with string values
+     */
+    static stringRecord(): ShadowStringRecord;
+    /**
+     * Creates a record schema with string keys and number values
+     * @returns A record schema with number values
+     */
+    static numberRecord(): ShadowNumberRecord;
+    /**
+     * Creates a record schema with string keys and boolean values
+     * @returns A record schema with boolean values
+     */
+    static booleanRecord(): ShadowBooleanRecord;
+    /**
+     * Creates a record schema with string keys and mixed values (string, number, or boolean)
+     * @returns A record schema with mixed values
+     */
+    static mixedRecord(): ShadowMixedRecord;
+    /**
+     * Creates an array schema
+     * @param type The type of items in the array
+     * @returns An array schema
+     */
+    static array<T extends ArrayTypes>(type: T): ShadowArray<T>;
+    /**
+     * Infers the TypeScript type from a Schema instance
+     * @template S The Schema type
+     * @returns The inferred TypeScript type
+     */
+    static infer<S extends Schema<Record<string, z.ZodTypeAny>>>(_schema: S): z.infer<S['schema']>;
+    /**
+     * Creates a Schema instance from a description object
+     * @param description Object describing the schema structure with type information
+     * @returns A new Schema instance
+     */
+    static from(description: SchemaDescription): Schema<Record<string, z.ZodType<string | boolean | number | Date | string[] | boolean[] | number[] | Date[] | Record<string, string | number | boolean>> | z.ZodOptional<z.ZodType<string | boolean | number | Date | string[] | boolean[] | number[] | Date[] | Record<string, string | number | boolean>>>>>;
+    /**
+     * Validates the provided data against the schema
+     * @param data The data to validate
+     * @returns A boolean indicating whether the data is valid
+     */
+    validate(data: unknown): boolean;
+    /**
+     * Parses and validates the provided data against the schema
+     * @param data The data to parse and validate
+     * @returns The parsed and typed data
+     * @throws {z.ZodError} If the data is invalid
+     */
+    parse(data: unknown): z.infer<z.ZodObject<T>>;
+    /**
+     * Safely parses and validates the provided data against the schema
+     * @param data The data to parse and validate
+     * @returns An object containing either the successfully parsed data or error information
+     */
+    safeParse(data: unknown): z.SafeParseReturnType<z.infer<z.ZodObject<T>>, z.infer<z.ZodObject<T>>>;
+    /**
+     * Describes the schema structure and allowed types
+     * @returns An object describing the schema structure with type information
+     */
+    describe(): SchemaDescription;
+}
+export default Schema;

package/dist/index.js

@@ -0,0 +1,285 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Schema = void 0;
+const zod_1 = require("zod");
+// Static methods for type definitions
+class Schema {
+    constructor(fields) {
+        this.schema = zod_1.z.object(fields);
+    }
+    /**
+     * Creates a string schema
+     * @returns A string schema
+     */
+    static string() {
+        return zod_1.z.string();
+    }
+    /**
+     * Creates a boolean schema
+     * @returns A boolean schema
+     */
+    static boolean() {
+        return zod_1.z.boolean();
+    }
+    /**
+     * Creates a number schema
+     * @returns A number schema
+     */
+    static number() {
+        return zod_1.z.number();
+    }
+    /**
+     * Creates a date schema
+     * @returns A date schema
+     */
+    static date() {
+        return zod_1.z.date();
+    }
+    /**
+     * Creates a record schema with string keys and string values
+     * @returns A record schema with string values
+     */
+    static stringRecord() {
+        return zod_1.z.record(zod_1.z.string(), zod_1.z.string());
+    }
+    /**
+     * Creates a record schema with string keys and number values
+     * @returns A record schema with number values
+     */
+    static numberRecord() {
+        return zod_1.z.record(zod_1.z.string(), zod_1.z.number());
+    }
+    /**
+     * Creates a record schema with string keys and boolean values
+     * @returns A record schema with boolean values
+     */
+    static booleanRecord() {
+        return zod_1.z.record(zod_1.z.string(), zod_1.z.boolean());
+    }
+    /**
+     * Creates a record schema with string keys and mixed values (string, number, or boolean)
+     * @returns A record schema with mixed values
+     */
+    static mixedRecord() {
+        return zod_1.z.record(zod_1.z.string(), zod_1.z.union([zod_1.z.string(), zod_1.z.number(), zod_1.z.boolean()]));
+    }
+    /**
+     * Creates an array schema
+     * @param type The type of items in the array
+     * @returns An array schema
+     */
+    static array(type) {
+        return zod_1.z.array(type);
+    }
+    /**
+     * Infers the TypeScript type from a Schema instance
+     * @template S The Schema type
+     * @returns The inferred TypeScript type
+     */
+    static infer(_schema) {
+        // This is a type-level utility, the implementation is not used at runtime
+        return {};
+    }
+    /**
+     * Creates a Schema instance from a description object
+     * @param description Object describing the schema structure with type information
+     * @returns A new Schema instance
+     */
+    static from(description) {
+        const fields = {};
+        for (const [key, field] of Object.entries(description)) {
+            const fieldType = field.type;
+            let fieldSchema;
+            switch (fieldType) {
+                case 'string': {
+                    let stringSchema = Schema.string();
+                    if (field.validations) {
+                        const validations = field.validations;
+                        if (validations.email) {
+                            stringSchema = stringSchema.email();
+                        }
+                        if (validations.minLength !== undefined) {
+                            stringSchema = stringSchema.min(validations.minLength);
+                        }
+                        if (validations.maxLength !== undefined) {
+                            stringSchema = stringSchema.max(validations.maxLength);
+                        }
+                        if (validations.regex !== undefined) {
+                            stringSchema = stringSchema.regex(new RegExp(validations.regex));
+                        }
+                    }
+                    fieldSchema = stringSchema;
+                    break;
+                }
+                case 'boolean':
+                    fieldSchema = Schema.boolean();
+                    break;
+                case 'number': {
+                    let numberSchema = Schema.number();
+                    if (field.validations) {
+                        const validations = field.validations;
+                        if (validations.min !== undefined) {
+                            numberSchema = numberSchema.min(validations.min);
+                        }
+                        if (validations.max !== undefined) {
+                            numberSchema = numberSchema.max(validations.max);
+                        }
+                    }
+                    fieldSchema = numberSchema;
+                    break;
+                }
+                case 'date':
+                    fieldSchema = Schema.date();
+                    break;
+                case 'stringRecord':
+                    fieldSchema = Schema.stringRecord();
+                    break;
+                case 'numberRecord':
+                    fieldSchema = Schema.numberRecord();
+                    break;
+                case 'booleanRecord':
+                    fieldSchema = Schema.booleanRecord();
+                    break;
+                case 'mixedRecord':
+                    fieldSchema = Schema.mixedRecord();
+                    break;
+                case 'array': {
+                    const arrayField = field;
+                    switch (arrayField.items.type) {
+                        case 'string':
+                            fieldSchema = Schema.array(Schema.string());
+                            break;
+                        case 'boolean':
+                            fieldSchema = Schema.array(Schema.boolean());
+                            break;
+                        case 'number':
+                            fieldSchema = Schema.array(Schema.number());
+                            break;
+                        case 'date':
+                            fieldSchema = Schema.array(Schema.date());
+                            break;
+                        default:
+                            throw new Error(`Unsupported array item type: ${arrayField.items.type}`);
+                    }
+                    break;
+                }
+                default:
+                    throw new Error(`Unsupported type: ${fieldType}`);
+            }
+            fields[key] = field.optional ? fieldSchema.optional() : fieldSchema;
+        }
+        return new Schema(fields);
+    }
+    /**
+     * Validates the provided data against the schema
+     * @param data The data to validate
+     * @returns A boolean indicating whether the data is valid
+     */
+    validate(data) {
+        const result = this.schema.safeParse(data);
+        return result.success;
+    }
+    /**
+     * Parses and validates the provided data against the schema
+     * @param data The data to parse and validate
+     * @returns The parsed and typed data
+     * @throws {z.ZodError} If the data is invalid
+     */
+    parse(data) {
+        return this.schema.parse(data);
+    }
+    /**
+     * Safely parses and validates the provided data against the schema
+     * @param data The data to parse and validate
+     * @returns An object containing either the successfully parsed data or error information
+     */
+    safeParse(data) {
+        return this.schema.safeParse(data);
+    }
+    /**
+     * Describes the schema structure and allowed types
+     * @returns An object describing the schema structure with type information
+     */
+    describe() {
+        const shape = this.schema.shape;
+        const description = {};
+        for (const [key, value] of Object.entries(shape)) {
+            const isOptional = value instanceof zod_1.z.ZodOptional;
+            const baseValue = isOptional ? value.unwrap() : value;
+            if (baseValue instanceof zod_1.z.ZodString) {
+                const validations = {};
+                if (baseValue._def.checks) {
+                    for (const check of baseValue._def.checks) {
+                        if (check.kind === 'email') {
+                            validations.email = true;
+                        }
+                        else if (check.kind === 'min') {
+                            validations.minLength = check.value;
+                        }
+                        else if (check.kind === 'max') {
+                            validations.maxLength = check.value;
+                        }
+                        else if (check.kind === 'regex') {
+                            validations.regex = check.regex.toString().replace(/^\/|\/$/g, '').replace(/\\\//g, '/');
+                        }
+                    }
+                }
+                description[key] = Object.assign(Object.assign({ type: 'string' }, (isOptional && { optional: true })), (Object.keys(validations).length > 0 && { validations }));
+            }
+            else if (baseValue instanceof zod_1.z.ZodBoolean) {
+                description[key] = Object.assign({ type: 'boolean' }, (isOptional && { optional: true }));
+            }
+            else if (baseValue instanceof zod_1.z.ZodNumber) {
+                const validations = {};
+                if (baseValue._def.checks) {
+                    for (const check of baseValue._def.checks) {
+                        if (check.kind === 'min') {
+                            validations.min = check.value;
+                        }
+                        else if (check.kind === 'max') {
+                            validations.max = check.value;
+                        }
+                    }
+                }
+                description[key] = Object.assign(Object.assign({ type: 'number' }, (isOptional && { optional: true })), (Object.keys(validations).length > 0 && { validations }));
+            }
+            else if (baseValue instanceof zod_1.z.ZodDate) {
+                description[key] = Object.assign({ type: 'date' }, (isOptional && { optional: true }));
+            }
+            else if (baseValue instanceof zod_1.z.ZodArray) {
+                const element = baseValue.element;
+                if (element instanceof zod_1.z.ZodString) {
+                    description[key] = Object.assign({ type: 'array', items: { type: 'string' } }, (isOptional && { optional: true }));
+                }
+                else if (element instanceof zod_1.z.ZodBoolean) {
+                    description[key] = Object.assign({ type: 'array', items: { type: 'boolean' } }, (isOptional && { optional: true }));
+                }
+                else if (element instanceof zod_1.z.ZodNumber) {
+                    description[key] = Object.assign({ type: 'array', items: { type: 'number' } }, (isOptional && { optional: true }));
+                }
+                else if (element instanceof zod_1.z.ZodDate) {
+                    description[key] = Object.assign({ type: 'array', items: { type: 'date' } }, (isOptional && { optional: true }));
+                }
+            }
+            else if (baseValue instanceof zod_1.z.ZodRecord) {
+                // Check the value type of the record
+                const valueType = baseValue._def.valueType;
+                if (valueType instanceof zod_1.z.ZodString) {
+                    description[key] = Object.assign({ type: 'stringRecord' }, (isOptional && { optional: true }));
+                }
+                else if (valueType instanceof zod_1.z.ZodNumber) {
+                    description[key] = Object.assign({ type: 'numberRecord' }, (isOptional && { optional: true }));
+                }
+                else if (valueType instanceof zod_1.z.ZodBoolean) {
+                    description[key] = Object.assign({ type: 'booleanRecord' }, (isOptional && { optional: true }));
+                }
+                else if (valueType instanceof zod_1.z.ZodUnion) {
+                    description[key] = Object.assign({ type: 'mixedRecord' }, (isOptional && { optional: true }));
+                }
+            }
+        }
+        return description;
+    }
+}
+exports.Schema = Schema;
+exports.default = Schema;

package/dist/test/custom-validations.test.d.ts

@@ -0,0 +1 @@
+export {};