added validator for rjsf, hook form via standard schema

app/src/core/index.ts

@@ -1,6 +1,5 @@
 import type { Hono, MiddlewareHandler } from "hono";
 
-export { tbValidator } from "./server/lib/tbValidator";
 export { Exception, BkndError } from "./errors";
 export { isDebug, env } from "./env";
 export { type PrimaryFieldType, config, type DB, type AppEntity } from "./config";

app/src/core/server/lib/index.ts

@@ -1 +0,0 @@
-export { tbValidator } from "./tbValidator";

app/src/core/server/lib/tbValidator.ts

@@ -1,37 +0,0 @@
-import type { StaticDecode, TSchema } from "@sinclair/typebox";
-import { Value, type ValueError } from "@sinclair/typebox/value";
-import type { Context, Env, MiddlewareHandler, ValidationTargets } from "hono";
-import { validator } from "hono/validator";
-
-type Hook<T, E extends Env, P extends string> = (
-   result: { success: true; data: T } | { success: false; errors: ValueError[] },
-   c: Context<E, P>,
-) => Response | Promise<Response> | void;
-
-export function tbValidator<
-   T extends TSchema,
-   Target extends keyof ValidationTargets,
-   E extends Env,
-   P extends string,
-   V extends { in: { [K in Target]: StaticDecode<T> }; out: { [K in Target]: StaticDecode<T> } },
->(target: Target, schema: T, hook?: Hook<StaticDecode<T>, E, P>): MiddlewareHandler<E, P, V> {
-   // Compile the provided schema once rather than per validation. This could be optimized further using a shared schema
-   // compilation pool similar to the Fastify implementation.
-
-   // @ts-expect-error not typed well
-   return validator(target, (data, c) => {
-      if (Value.Check(schema, data)) {
-         // always decode
-         const decoded = Value.Decode(schema, data);
-
-         if (hook) {
-            const hookResult = hook({ success: true, data: decoded }, c);
-            if (hookResult instanceof Response || hookResult instanceof Promise) {
-               return hookResult;
-            }
-         }
-         return decoded;
-      }
-      return c.json({ success: false, errors: [...Value.Errors(schema, data)] }, 400);
-   });
-}

app/src/core/utils/index.ts

@@ -7,11 +7,9 @@ export * from "./file";
 export * from "./reqres";
 export * from "./xml";
 export type { Prettify, PrettifyRec, RecursivePartial } from "./types";
-export * from "./typebox";
 export * from "./dates";
 export * from "./crypto";
 export * from "./uuid";
-export { FromSchema } from "./typebox/from-schema";
 export * from "./test";
 export * from "./runtime";
 export * from "./numbers";

app/src/core/utils/typebox/from-schema.ts

@@ -1,270 +0,0 @@
-/*--------------------------------------------------------------------------
-
-@sinclair/typebox/prototypes
-
-The MIT License (MIT)
-
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
-
-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.
-
----------------------------------------------------------------------------*/
-
-import * as Type from "@sinclair/typebox";
-
-// ------------------------------------------------------------------
-// Schematics
-// ------------------------------------------------------------------
-const IsExact = (value: unknown, expect: unknown) => value === expect;
-const IsSValue = (value: unknown): value is SValue =>
-   Type.ValueGuard.IsString(value) ||
-   Type.ValueGuard.IsNumber(value) ||
-   Type.ValueGuard.IsBoolean(value);
-const IsSEnum = (value: unknown): value is SEnum =>
-   Type.ValueGuard.IsObject(value) &&
-   Type.ValueGuard.IsArray(value.enum) &&
-   value.enum.every((value) => IsSValue(value));
-const IsSAllOf = (value: unknown): value is SAllOf =>
-   Type.ValueGuard.IsObject(value) && Type.ValueGuard.IsArray(value.allOf);
-const IsSAnyOf = (value: unknown): value is SAnyOf =>
-   Type.ValueGuard.IsObject(value) && Type.ValueGuard.IsArray(value.anyOf);
-const IsSOneOf = (value: unknown): value is SOneOf =>
-   Type.ValueGuard.IsObject(value) && Type.ValueGuard.IsArray(value.oneOf);
-const IsSTuple = (value: unknown): value is STuple =>
-   Type.ValueGuard.IsObject(value) &&
-   IsExact(value.type, "array") &&
-   Type.ValueGuard.IsArray(value.items);
-const IsSArray = (value: unknown): value is SArray =>
-   Type.ValueGuard.IsObject(value) &&
-   IsExact(value.type, "array") &&
-   !Type.ValueGuard.IsArray(value.items) &&
-   Type.ValueGuard.IsObject(value.items);
-const IsSConst = (value: unknown): value is SConst =>
-   // biome-ignore lint/complexity/useLiteralKeys: <explanation>
-   Type.ValueGuard.IsObject(value) && Type.ValueGuard.IsObject(value["const"]);
-const IsSString = (value: unknown): value is SString =>
-   Type.ValueGuard.IsObject(value) && IsExact(value.type, "string");
-const IsSNumber = (value: unknown): value is SNumber =>
-   Type.ValueGuard.IsObject(value) && IsExact(value.type, "number");
-const IsSInteger = (value: unknown): value is SInteger =>
-   Type.ValueGuard.IsObject(value) && IsExact(value.type, "integer");
-const IsSBoolean = (value: unknown): value is SBoolean =>
-   Type.ValueGuard.IsObject(value) && IsExact(value.type, "boolean");
-const IsSNull = (value: unknown): value is SBoolean =>
-   Type.ValueGuard.IsObject(value) && IsExact(value.type, "null");
-const IsSProperties = (value: unknown): value is SProperties => Type.ValueGuard.IsObject(value);
-// biome-ignore format: keep
-const IsSObject = (value: unknown): value is SObject => Type.ValueGuard.IsObject(value) && IsExact(value.type, 'object') && IsSProperties(value.properties) && (value.required === undefined || Type.ValueGuard.IsArray(value.required) && value.required.every((value: unknown) => Type.ValueGuard.IsString(value)))
-type SValue = string | number | boolean;
-type SEnum = Readonly<{ enum: readonly SValue[] }>;
-type SAllOf = Readonly<{ allOf: readonly unknown[] }>;
-type SAnyOf = Readonly<{ anyOf: readonly unknown[] }>;
-type SOneOf = Readonly<{ oneOf: readonly unknown[] }>;
-type SProperties = Record<PropertyKey, unknown>;
-type SObject = Readonly<{ type: "object"; properties: SProperties; required?: readonly string[] }>;
-type STuple = Readonly<{ type: "array"; items: readonly unknown[] }>;
-type SArray = Readonly<{ type: "array"; items: unknown }>;
-type SConst = Readonly<{ const: SValue }>;
-type SString = Readonly<{ type: "string" }>;
-type SNumber = Readonly<{ type: "number" }>;
-type SInteger = Readonly<{ type: "integer" }>;
-type SBoolean = Readonly<{ type: "boolean" }>;
-type SNull = Readonly<{ type: "null" }>;
-// ------------------------------------------------------------------
-// FromRest
-// ------------------------------------------------------------------
-// biome-ignore format: keep
-type TFromRest<T extends readonly unknown[], Acc extends Type.TSchema[] = []> = (
-  // biome-ignore lint/complexity/noUselessTypeConstraint: <explanation>
-  T extends readonly [infer L extends unknown, ...infer R extends unknown[]]
-    ? TFromSchema<L> extends infer S extends Type.TSchema
-      ? TFromRest<R, [...Acc, S]>
-      : TFromRest<R, [...Acc]>
-    : Acc
-)
-function FromRest<T extends readonly unknown[]>(T: T): TFromRest<T> {
-   return T.map((L) => FromSchema(L)) as never;
-}
-// ------------------------------------------------------------------
-// FromEnumRest
-// ------------------------------------------------------------------
-// biome-ignore format: keep
-type TFromEnumRest<T extends readonly SValue[], Acc extends Type.TSchema[] = []> = (
-  T extends readonly [infer L extends SValue, ...infer R extends SValue[]]
-    ? TFromEnumRest<R, [...Acc, Type.TLiteral<L>]>
-    : Acc
-)
-function FromEnumRest<T extends readonly SValue[]>(T: T): TFromEnumRest<T> {
-   return T.map((L) => Type.Literal(L)) as never;
-}
-// ------------------------------------------------------------------
-// AllOf
-// ------------------------------------------------------------------
-// biome-ignore format: keep
-type TFromAllOf<T extends SAllOf> = (
-  TFromRest<T['allOf']> extends infer Rest extends Type.TSchema[]
-    ? Type.TIntersectEvaluated<Rest>
-    : Type.TNever
-)
-function FromAllOf<T extends SAllOf>(T: T): TFromAllOf<T> {
-   return Type.IntersectEvaluated(FromRest(T.allOf), T);
-}
-// ------------------------------------------------------------------
-// AnyOf
-// ------------------------------------------------------------------
-// biome-ignore format: keep
-type TFromAnyOf<T extends SAnyOf> = (
-  TFromRest<T['anyOf']> extends infer Rest extends Type.TSchema[]
-    ? Type.TUnionEvaluated<Rest>
-    : Type.TNever
-)
-function FromAnyOf<T extends SAnyOf>(T: T): TFromAnyOf<T> {
-   return Type.UnionEvaluated(FromRest(T.anyOf), T);
-}
-// ------------------------------------------------------------------
-// OneOf
-// ------------------------------------------------------------------
-// biome-ignore format: keep
-type TFromOneOf<T extends SOneOf> = (
-  TFromRest<T['oneOf']> extends infer Rest extends Type.TSchema[]
-    ? Type.TUnionEvaluated<Rest>
-    : Type.TNever
-)
-function FromOneOf<T extends SOneOf>(T: T): TFromOneOf<T> {
-   return Type.UnionEvaluated(FromRest(T.oneOf), T);
-}
-// ------------------------------------------------------------------
-// Enum
-// ------------------------------------------------------------------
-// biome-ignore format: keep
-type TFromEnum<T extends SEnum> = (
-  TFromEnumRest<T['enum']> extends infer Elements extends Type.TSchema[]
-    ? Type.TUnionEvaluated<Elements>
-    : Type.TNever
-)
-function FromEnum<T extends SEnum>(T: T): TFromEnum<T> {
-   return Type.UnionEvaluated(FromEnumRest(T.enum));
-}
-// ------------------------------------------------------------------
-// Tuple
-// ------------------------------------------------------------------
-// biome-ignore format: keep
-type TFromTuple<T extends STuple> = (
-  TFromRest<T['items']> extends infer Elements extends Type.TSchema[]
-    ? Type.TTuple<Elements>
-    : Type.TTuple<[]>
-)
-// biome-ignore format: keep
-function FromTuple<T extends STuple>(T: T): TFromTuple<T> {
-  return Type.Tuple(FromRest(T.items), T) as never
-}
-// ------------------------------------------------------------------
-// Array
-// ------------------------------------------------------------------
-// biome-ignore format: keep
-type TFromArray<T extends SArray> = (
-  TFromSchema<T['items']> extends infer Items extends Type.TSchema
-    ? Type.TArray<Items>
-    : Type.TArray<Type.TUnknown>
-)
-// biome-ignore format: keep
-function FromArray<T extends SArray>(T: T): TFromArray<T> {
-  return Type.Array(FromSchema(T.items), T) as never
-}
-// ------------------------------------------------------------------
-// Const
-// ------------------------------------------------------------------
-// biome-ignore format: keep
-type TFromConst<T extends SConst> = (
-  Type.Ensure<Type.TLiteral<T['const']>>
-)
-function FromConst<T extends SConst>(T: T) {
-   return Type.Literal(T.const, T);
-}
-// ------------------------------------------------------------------
-// Object
-// ------------------------------------------------------------------
-type TFromPropertiesIsOptional<
-   K extends PropertyKey,
-   R extends string | unknown,
-> = unknown extends R ? true : K extends R ? false : true;
-// biome-ignore format: keep
-type TFromProperties<T extends SProperties, R extends string | unknown> = Type.Evaluate<{
-  -readonly [K in keyof T]: TFromPropertiesIsOptional<K, R> extends true
-    ? Type.TOptional<TFromSchema<T[K]>>
-    : TFromSchema<T[K]>
-}>
-// biome-ignore format: keep
-type TFromObject<T extends SObject> = (
-  TFromProperties<T['properties'], Exclude<T['required'], undefined>[number]> extends infer Properties extends Type.TProperties
-    ? Type.TObject<Properties>
-    : Type.TObject<{}>
-)
-function FromObject<T extends SObject>(T: T): TFromObject<T> {
-   const properties = globalThis.Object.getOwnPropertyNames(T.properties).reduce((Acc, K) => {
-      return {
-         // biome-ignore lint/performance/noAccumulatingSpread: <explanation>
-         ...Acc,
-         [K]: T.required?.includes(K)
-            ? FromSchema(T.properties[K])
-            : Type.Optional(FromSchema(T.properties[K])),
-      };
-   }, {} as Type.TProperties);
-   return Type.Object(properties, T) as never;
-}
-// ------------------------------------------------------------------
-// FromSchema
-// ------------------------------------------------------------------
-// biome-ignore format: keep
-export type TFromSchema<T> = (
-  T extends SAllOf ? TFromAllOf<T> :
-  T extends SAnyOf ? TFromAnyOf<T> :
-  T extends SOneOf ? TFromOneOf<T> :
-  T extends SEnum ? TFromEnum<T> :
-  T extends SObject ? TFromObject<T> :
-  T extends STuple ? TFromTuple<T> :
-  T extends SArray ? TFromArray<T> :
-  T extends SConst ? TFromConst<T> :
-  T extends SString ? Type.TString :
-  T extends SNumber ? Type.TNumber :
-  T extends SInteger ? Type.TInteger :
-  T extends SBoolean ? Type.TBoolean :
-  T extends SNull ? Type.TNull :
-  Type.TUnknown
-)
-/** Parses a TypeBox type from raw JsonSchema */
-export function FromSchema<T>(T: T): TFromSchema<T> {
-   // biome-ignore format: keep
-   return (
-    IsSAllOf(T) ? FromAllOf(T) :
-    IsSAnyOf(T) ? FromAnyOf(T) :
-    IsSOneOf(T) ? FromOneOf(T) :
-    IsSEnum(T) ? FromEnum(T) : 
-    IsSObject(T) ? FromObject(T) :
-    IsSTuple(T) ? FromTuple(T) :
-    IsSArray(T) ? FromArray(T) :
-    IsSConst(T) ? FromConst(T) :
-    IsSString(T) ? Type.String(T) :
-    IsSNumber(T) ? Type.Number(T) :
-    IsSInteger(T) ? Type.Integer(T) :
-    IsSBoolean(T) ? Type.Boolean(T) :
-    IsSNull(T) ? Type.Null(T) :
-    Type.Unknown(T || {})
-  ) as never
-}

app/src/core/utils/typebox/index.ts

@@ -1,194 +0,0 @@
-import * as tb from "@sinclair/typebox";
-import type {
-   TypeRegistry,
-   Static,
-   StaticDecode,
-   TSchema,
-   SchemaOptions,
-   TObject,
-} from "@sinclair/typebox";
-import {
-   DefaultErrorFunction,
-   Errors,
-   SetErrorFunction,
-   type ValueErrorIterator,
-} from "@sinclair/typebox/errors";
-import { Check, Default, Value, type ValueError } from "@sinclair/typebox/value";
-import type { RecursivePartial } from "../types";
-
-/* type ParseOptions = {
-   useDefaults?: boolean;
-   decode?: boolean;
-   onError?: (errors: ValueErrorIterator) => void;
-   forceParse?: boolean;
-   skipMark?: boolean;
-};
-
-const validationSymbol = Symbol("tb-parse-validation");
-
-export class TypeInvalidError extends Error {
-   errors: ValueError[];
-   constructor(
-      public schema: tb.TSchema,
-      public data: unknown,
-      message?: string,
-   ) {
-      //console.warn("errored schema", JSON.stringify(schema, null, 2));
-      super(message ?? `Invalid: ${JSON.stringify(data)}`);
-      this.errors = [...Errors(schema, data)];
-   }
-
-   first() {
-      return this.errors[0]!;
-   }
-
-   firstToString() {
-      const first = this.first();
-      return `${first.message} at "${first.path}"`;
-   }
-
-   toJSON() {
-      return {
-         message: this.message,
-         schema: this.schema,
-         data: this.data,
-         errors: this.errors,
-      };
-   }
-}
-
-export function stripMark<O = any>(obj: O) {
-   const newObj = structuredClone(obj);
-   mark(newObj, false);
-   return newObj as O;
-}
-
-export function mark(obj: any, validated = true) {
-   if (typeof obj === "object" && obj !== null && !Array.isArray(obj)) {
-      if (validated) {
-         obj[validationSymbol] = true;
-      } else {
-         delete obj[validationSymbol];
-      }
-      for (const key in obj) {
-         if (typeof obj[key] === "object" && obj[key] !== null) {
-            mark(obj[key], validated);
-         }
-      }
-   }
-}
-
-export function parse<Schema extends tb.TSchema = tb.TSchema>(
-   schema: Schema,
-   data: RecursivePartial<tb.Static<Schema>>,
-   options?: ParseOptions,
-): tb.Static<Schema> {
-   if (!options?.forceParse && typeof data === "object" && validationSymbol in data) {
-      if (options?.useDefaults === false) {
-         return data as tb.Static<typeof schema>;
-      }
-
-      // this is important as defaults are expected
-      return Default(schema, data as any) as tb.Static<Schema>;
-   }
-
-   const parsed = options?.useDefaults === false ? data : Default(schema, data);
-
-   if (Check(schema, parsed)) {
-      options?.skipMark !== true && mark(parsed, true);
-      return parsed as tb.Static<typeof schema>;
-   } else if (options?.onError) {
-      options.onError(Errors(schema, data));
-   } else {
-      throw new TypeInvalidError(schema, data);
-   }
-
-   // @todo: check this
-   return undefined as any;
-}
-
-export function parseDecode<Schema extends tb.TSchema = tb.TSchema>(
-   schema: Schema,
-   data: RecursivePartial<tb.StaticDecode<Schema>>,
-): tb.StaticDecode<Schema> {
-   const parsed = Default(schema, data);
-
-   if (Check(schema, parsed)) {
-      return parsed as tb.StaticDecode<typeof schema>;
-   }
-
-   throw new TypeInvalidError(schema, data);
-}
-
-export function strictParse<Schema extends tb.TSchema = tb.TSchema>(
-   schema: Schema,
-   data: tb.Static<Schema>,
-   options?: ParseOptions,
-): tb.Static<Schema> {
-   return parse(schema, data as any, options);
-}
-
-export function registerCustomTypeboxKinds(registry: typeof TypeRegistry) {
-   registry.Set("StringEnum", (schema: any, value: any) => {
-      return typeof value === "string" && schema.enum.includes(value);
-   });
-}
-registerCustomTypeboxKinds(tb.TypeRegistry);
-
-export const StringEnum = <const T extends readonly string[]>(
-   values: T,
-   options?: tb.StringOptions,
-) =>
-   tb.Type.Unsafe<T[number]>({
-      [tb.Kind]: "StringEnum",
-      type: "string",
-      enum: values,
-      ...options,
-   });
-
-// key value record compatible with RJSF and typebox inference
-// acting like a Record, but using an Object with additionalProperties
-export const StringRecord = <T extends tb.TSchema>(properties: T, options?: tb.ObjectOptions) =>
-   tb.Type.Object({}, { ...options, additionalProperties: properties }) as unknown as tb.TRecord<
-      tb.TString,
-      typeof properties
-   >;
-
-// fixed value that only be what is given + prefilled
-export const Const = <T extends tb.TLiteralValue = tb.TLiteralValue>(
-   value: T,
-   options?: tb.SchemaOptions,
-) =>
-   tb.Type.Literal(value, {
-      ...options,
-      default: value,
-      const: value,
-      readOnly: true,
-   }) as tb.TLiteral<T>;
-
-export const StringIdentifier = tb.Type.String({
-   pattern: "^[a-zA-Z_][a-zA-Z0-9_]*$",
-   minLength: 2,
-   maxLength: 150,
-});
-
-export const StrictObject = <T extends tb.TProperties>(
-   properties: T,
-   options?: tb.ObjectOptions,
-): tb.TObject<T> => tb.Type.Object(properties, { ...options, additionalProperties: false });
-
-SetErrorFunction((error) => {
-   if (error?.schema?.errorMessage) {
-      return error.schema.errorMessage;
-   }
-
-   if (error?.schema?.[tb.Kind] === "StringEnum") {
-      return `Expected: ${error.schema.enum.map((e) => `"${e}"`).join(", ")}`;
-   }
-
-   return DefaultErrorFunction(error);
-});
-
-export type { Static, StaticDecode, TSchema, TObject, ValueError, SchemaOptions };
-
-export { Value, Default, Errors, Check }; */