orchid-orm-valibot 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Roman Kushyn
+
+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/README.md

@@ -0,0 +1,5 @@
+# Orchid ORM schema to zod converter
+
+[Valibot](https://valibot.dev/) integration for OrchidORM.
+
+[Read docs here](https://orchid-orm.netlify.app/guide/columns-validation-methods.html).

package/dist/index.d.ts

@@ -0,0 +1,243 @@
+import { ParseColumn, EncodeColumn, AsTypeArg, ColumnTypeBase, NullableColumn, ColumnSchemaGetterTableClass, ColumnSchemaGetterColumns, Code, ErrorMessage, StringTypeData } from 'orchid-core';
+import { EnumColumn, ArrayColumnValue, ColumnType, OperatorsJson, ColumnData, ArrayColumn, SmallIntColumn, IntegerColumn, RealColumn, SmallSerialColumn, SerialColumn, BigIntColumn, DecimalColumn, DoublePrecisionColumn, BigSerialColumn, MoneyColumn, VarCharColumn, CharColumn, TextColumn, StringColumn, CitextColumn, DateColumn, TimestampColumn, TimestampTZColumn } from 'pqb';
+import { BaseValidation, BaseSchema, Output, PicklistSchema, NullableSchema, UnknownSchema, BooleanSchema, InstanceSchema, NeverSchema, StringSchema, NumberSchema, DateSchema, ObjectSchema, OptionalSchema, ArraySchema } from 'valibot';
+
+type ParseDateToNumber = ParseColumn<DateColumnValibot, NumberSchema, number>;
+type ParseDateToDate = ParseColumn<DateColumnValibot, DateSchema, Date>;
+declare class ValibotJSONColumn<Schema extends BaseSchema> extends ColumnType<ValibotSchemaConfig, Output<Schema>, Schema, OperatorsJson> {
+    dataType: "jsonb";
+    operators: OperatorsJson;
+    data: ColumnData;
+    constructor(schema: Schema);
+    toCode(t: string): Code;
+}
+interface ArrayMethods<Value> {
+    min<T extends ColumnTypeBase>(this: T, value: Value, params?: ErrorMessage): T;
+    max<T extends ColumnTypeBase>(this: T, value: Value, params?: ErrorMessage): T;
+    length<T extends ColumnTypeBase>(this: T, value: Value, params?: ErrorMessage): T;
+    nonEmpty<T extends ColumnTypeBase>(this: T, params?: ErrorMessage): T;
+}
+interface ValibotArrayColumn<Item extends ArrayColumnValue> extends ArrayColumn<ValibotSchemaConfig, Item, ArraySchema<Item['inputSchema']>, ArraySchema<Item['outputSchema']>, ArraySchema<Item['querySchema']>>, ArrayMethods<number> {
+}
+declare class ValibotArrayColumn<Item extends ArrayColumnValue> extends ArrayColumn<ValibotSchemaConfig, Item, ArraySchema<Item['inputSchema']>, ArraySchema<Item['outputSchema']>, ArraySchema<Item['querySchema']>> {
+    constructor(item: Item);
+}
+interface NumberMethods {
+    lt<T extends ColumnTypeBase>(this: T, value: number, params?: ErrorMessage): T;
+    lte<T extends ColumnTypeBase>(this: T, value: number, params?: ErrorMessage): T;
+    max<T extends ColumnTypeBase>(this: T, value: number, params?: ErrorMessage): T;
+    gt<T extends ColumnTypeBase>(this: T, value: number, params?: ErrorMessage): T;
+    gte<T extends ColumnTypeBase>(this: T, value: number, params?: ErrorMessage): T;
+    min<T extends ColumnTypeBase>(this: T, value: number, params?: ErrorMessage): T;
+    positive<T extends ColumnTypeBase>(this: T, params?: ErrorMessage): T;
+    nonNegative<T extends ColumnTypeBase>(this: T, params?: ErrorMessage): T;
+    negative<T extends ColumnTypeBase>(this: T, params?: ErrorMessage): T;
+    nonPositive<T extends ColumnTypeBase>(this: T, params?: ErrorMessage): T;
+    step<T extends ColumnTypeBase>(this: T, value: number, params?: ErrorMessage): T;
+    int<T extends ColumnTypeBase>(this: T, params?: ErrorMessage): T;
+    finite<T extends ColumnTypeBase>(this: T, params?: ErrorMessage): T;
+    safe<T extends ColumnTypeBase>(this: T, params?: ErrorMessage): T;
+}
+type GtValidation<TInput extends string | number | bigint | boolean | Date, TRequirement extends TInput> = BaseValidation<TInput> & {
+    /**
+     * The validation type.
+     */
+    type: 'gt';
+    /**
+     * The maximum value.
+     */
+    requirement: TRequirement;
+};
+declare function gt<TInput extends string | number | bigint | Date, TRequirement extends TInput>(requirement: TRequirement, message?: string): GtValidation<TInput, TRequirement>;
+type LtValidation<TInput extends string | number | bigint | boolean | Date, TRequirement extends TInput> = BaseValidation<TInput> & {
+    /**
+     * The validation type.
+     */
+    type: 'lt';
+    /**
+     * The maximum value.
+     */
+    requirement: TRequirement;
+};
+declare function lt<TInput extends string | number | bigint | Date, TRequirement extends TInput>(requirement: TRequirement, message?: string): LtValidation<TInput, TRequirement>;
+type StepValidation<TInput extends number, TRequirement extends TInput> = BaseValidation<TInput> & {
+    /**
+     * The validation type.
+     */
+    type: 'step';
+    /**
+     * The maximum value.
+     */
+    requirement: TRequirement;
+};
+declare function step<TInput extends number, TRequirement extends TInput>(requirement: TRequirement, message?: string): StepValidation<TInput, TRequirement>;
+interface SmallIntColumnValibot extends SmallIntColumn<ValibotSchemaConfig>, NumberMethods {
+}
+declare class SmallIntColumnValibot extends SmallIntColumn<ValibotSchemaConfig> {
+}
+interface IntegerColumnValibot extends IntegerColumn<ValibotSchemaConfig>, NumberMethods {
+}
+declare class IntegerColumnValibot extends IntegerColumn<ValibotSchemaConfig> {
+}
+interface RealColumnValibot extends RealColumn<ValibotSchemaConfig>, NumberMethods {
+}
+declare class RealColumnValibot extends RealColumn<ValibotSchemaConfig> {
+}
+interface SmallSerialColumnValibot extends SmallSerialColumn<ValibotSchemaConfig>, NumberMethods {
+}
+declare class SmallSerialColumnValibot extends SmallSerialColumn<ValibotSchemaConfig> {
+}
+interface SerialColumnValibot extends SerialColumn<ValibotSchemaConfig>, NumberMethods {
+}
+declare class SerialColumnValibot extends SerialColumn<ValibotSchemaConfig> {
+}
+interface StringMethods extends ArrayMethods<number> {
+    email<T extends ColumnTypeBase>(this: T, params?: ErrorMessage): T;
+    url<T extends ColumnTypeBase>(this: T, params?: ErrorMessage): T;
+    emoji<T extends ColumnTypeBase>(this: T, params?: ErrorMessage): T;
+    uuid<T extends ColumnTypeBase>(this: T, params?: ErrorMessage): T;
+    cuid2<T extends ColumnTypeBase>(this: T, params?: ErrorMessage): T;
+    ulid<T extends ColumnTypeBase>(this: T, params?: ErrorMessage): T;
+    regex<T extends ColumnTypeBase>(this: T, value: RegExp, params?: ErrorMessage): T;
+    includes<T extends ColumnTypeBase, Value extends string>(this: T, value: Value, params?: ErrorMessage): T;
+    startsWith<T extends ColumnTypeBase, Value extends string>(this: T, value: Value, params?: ErrorMessage): T;
+    endsWith<T extends ColumnTypeBase, Value extends string>(this: T, value: Value, params?: ErrorMessage): T;
+    datetime<T extends ColumnTypeBase>(this: T, params?: StringTypeData['datetime'] & Exclude<ErrorMessage, string>): T;
+    ip<T extends ColumnTypeBase>(this: T, params?: StringTypeData['ip'] & Exclude<ErrorMessage, string>): T;
+    trim<T extends ColumnTypeBase>(this: T, params?: ErrorMessage): T;
+    toLowerCase<T extends ColumnTypeBase>(this: T, params?: ErrorMessage): T;
+    toUpperCase<T extends ColumnTypeBase>(this: T, params?: ErrorMessage): T;
+}
+interface BigIntColumnValibot extends BigIntColumn<ValibotSchemaConfig>, StringMethods {
+}
+declare class BigIntColumnValibot extends BigIntColumn<ValibotSchemaConfig> {
+}
+interface DecimalColumnValibot extends DecimalColumn<ValibotSchemaConfig>, StringMethods {
+}
+declare class DecimalColumnValibot extends DecimalColumn<ValibotSchemaConfig> {
+}
+interface DoublePrecisionColumnValibot extends DoublePrecisionColumn<ValibotSchemaConfig>, StringMethods {
+}
+declare class DoublePrecisionColumnValibot extends DoublePrecisionColumn<ValibotSchemaConfig> {
+}
+interface BigSerialColumnValibot extends BigSerialColumn<ValibotSchemaConfig>, StringMethods {
+}
+declare class BigSerialColumnValibot extends BigSerialColumn<ValibotSchemaConfig> {
+}
+interface MoneyColumnValibot extends MoneyColumn<ValibotSchemaConfig>, StringMethods {
+}
+declare class MoneyColumnValibot extends MoneyColumn<ValibotSchemaConfig> {
+}
+interface VarCharColumnValibot extends VarCharColumn<ValibotSchemaConfig>, StringMethods {
+}
+declare class VarCharColumnValibot extends VarCharColumn<ValibotSchemaConfig> {
+}
+interface CharColumnValibot extends CharColumn<ValibotSchemaConfig>, StringMethods {
+}
+declare class CharColumnValibot extends CharColumn<ValibotSchemaConfig> {
+}
+interface TextColumnValibot extends TextColumn<ValibotSchemaConfig>, StringMethods {
+}
+declare class TextColumnValibot extends TextColumn<ValibotSchemaConfig> {
+}
+interface StringColumnValibot extends StringColumn<ValibotSchemaConfig>, StringMethods {
+}
+declare class StringColumnValibot extends StringColumn<ValibotSchemaConfig> {
+}
+interface CitextColumnValibot extends CitextColumn<ValibotSchemaConfig>, StringMethods {
+}
+declare class CitextColumnValibot extends CitextColumn<ValibotSchemaConfig> {
+}
+interface DateMethods {
+    min<T extends ColumnTypeBase>(this: T, value: Date, params?: ErrorMessage): T;
+    max<T extends ColumnTypeBase>(this: T, value: Date, params?: ErrorMessage): T;
+}
+interface DateColumnValibot extends DateColumn<ValibotSchemaConfig>, DateMethods {
+}
+declare class DateColumnValibot extends DateColumn<ValibotSchemaConfig> {
+}
+interface TimestampNoTzColumnValibot extends TimestampColumn<ValibotSchemaConfig>, DateMethods {
+}
+declare class TimestampNoTzColumnValibot extends TimestampColumn<ValibotSchemaConfig> {
+}
+interface TimestampColumnValibot extends TimestampTZColumn<ValibotSchemaConfig>, DateMethods {
+}
+declare class TimestampColumnValibot extends TimestampTZColumn<ValibotSchemaConfig> {
+}
+interface ValibotSchemaConfig {
+    type: BaseSchema;
+    parse<T extends {
+        type: unknown;
+    }, OutputSchema extends BaseSchema, Out = Output<OutputSchema>>(this: T, _schema: OutputSchema, fn: (input: T['type']) => Out): ParseColumn<T, OutputSchema, Out>;
+    encode<T extends {
+        type: unknown;
+    }, InputSchema extends BaseSchema, In = Output<InputSchema>>(this: T, _schema: InputSchema, fn: (input: In) => unknown): EncodeColumn<T, InputSchema, In>;
+    asType<T, Types extends AsTypeArg<BaseSchema>, TypeSchema extends BaseSchema = Types extends {
+        type: BaseSchema;
+    } ? Types['type'] : never, Type = Output<TypeSchema>>(this: T, types: Types): {
+        [K in keyof T]: K extends 'type' ? Type : K extends 'inputType' ? Types['input'] extends BaseSchema ? Output<Types['input']> : Type : K extends 'inputSchema' ? Types['input'] extends BaseSchema ? Types['input'] : TypeSchema : K extends 'outputType' ? Types['output'] extends BaseSchema ? Output<Types['output']> : Type : K extends 'outputSchema' ? Types['output'] extends BaseSchema ? Types['output'] : TypeSchema : K extends 'queryType' ? Types['query'] extends BaseSchema ? Output<Types['query']> : Type : K extends 'querySchema' ? Types['query'] extends BaseSchema ? Types['query'] : TypeSchema : T[K];
+    };
+    dateAsNumber(): ParseDateToNumber;
+    dateAsDate(): ParseDateToDate;
+    enum<U extends string, T extends [U, ...U[]]>(dataType: string, type: T): EnumColumn<ValibotSchemaConfig, PicklistSchema<T>, U, T>;
+    array<Item extends ArrayColumnValue>(item: Item): ValibotArrayColumn<Item>;
+    nullable<T extends ColumnTypeBase>(this: T): NullableColumn<T, NullableSchema<T['inputSchema']>, NullableSchema<T['outputSchema']>, NullableSchema<T['querySchema']>>;
+    json<Schema extends BaseSchema = UnknownSchema>(schema?: Schema): ValibotJSONColumn<Schema>;
+    boolean(): BooleanSchema;
+    buffer(): InstanceSchema<typeof Buffer>;
+    unknown(): UnknownSchema;
+    never(): NeverSchema;
+    stringSchema(): StringSchema;
+    stringMin(max: number): StringSchema;
+    stringMax(max: number): StringSchema;
+    stringMinMax(min: number, max: number): StringSchema;
+    number(): NumberSchema;
+    int(): NumberSchema;
+    stringNumberDate(): DateSchema;
+    timeInterval(): ObjectSchema<{
+        years: OptionalSchema<NumberSchema>;
+        months: OptionalSchema<NumberSchema>;
+        days: OptionalSchema<NumberSchema>;
+        hours: OptionalSchema<NumberSchema>;
+        minutes: OptionalSchema<NumberSchema>;
+        seconds: OptionalSchema<NumberSchema>;
+    }>;
+    bit(max: number): StringSchema;
+    uuid(): StringSchema;
+    inputSchema<T extends ColumnSchemaGetterTableClass>(this: T): MapSchema<T, 'inputSchema'>;
+    outputSchema<T extends ColumnSchemaGetterTableClass>(this: T): MapSchema<T, 'outputSchema'>;
+    querySchema<T extends ColumnSchemaGetterTableClass>(this: T): MapSchema<T, 'querySchema'>;
+    updateSchema<T extends ColumnSchemaGetterTableClass>(this: T): UpdateSchema<T>;
+    pkeySchema<T extends ColumnSchemaGetterTableClass>(this: T): PkeySchema<T>;
+    error<T extends ColumnTypeBase<ValibotSchemaConfig>>(this: T, message: string): T;
+    smallint(): SmallIntColumnValibot;
+    integer(): IntegerColumnValibot;
+    real(): RealColumnValibot;
+    smallSerial(): SmallSerialColumnValibot;
+    serial(): SerialColumnValibot;
+    bigint(): BigIntColumnValibot;
+    decimal(precision?: number, scale?: number): DecimalColumnValibot;
+    doublePrecision(): DoublePrecisionColumnValibot;
+    bigSerial(): BigSerialColumnValibot;
+    money(): MoneyColumnValibot;
+    varchar(limit?: number): VarCharColumnValibot;
+    char(limit?: number): CharColumnValibot;
+    text(min: number, max: number): TextColumnValibot;
+    string(limit?: number): StringColumnValibot;
+    citext(min: number, max: number): CitextColumnValibot;
+    date(): DateColumnValibot;
+    timestampNoTZ(precision?: number): TimestampNoTzColumnValibot;
+    timestamp(precision?: number): TimestampColumnValibot;
+}
+declare const valibotSchemaConfig: ValibotSchemaConfig;
+type MapSchema<T extends ColumnSchemaGetterTableClass, Key extends 'inputSchema' | 'outputSchema' | 'querySchema'> = ObjectSchema<{
+    [K in keyof ColumnSchemaGetterColumns<T>]: ColumnSchemaGetterColumns<T>[K][Key];
+}>;
+type UpdateSchema<T extends ColumnSchemaGetterTableClass> = ObjectSchema<{
+    [K in keyof ColumnSchemaGetterColumns<T>]: OptionalSchema<ColumnSchemaGetterColumns<T>[K]['inputSchema']>;
+}>;
+type PkeySchema<T extends ColumnSchemaGetterTableClass> = ObjectSchema<{
+    [K in keyof ColumnSchemaGetterColumns<T> as ColumnSchemaGetterColumns<T>[K]['data']['isPrimaryKey'] extends true ? K : never]: ColumnSchemaGetterColumns<T>[K]['inputSchema'];
+}>;
+
+export { GtValidation, LtValidation, StepValidation, ValibotSchemaConfig, gt, lt, step, valibotSchemaConfig };