Release 0.16 (#196)

* initial refactor

* fixes

* test secrets extraction

* updated lock

* fix secret schema

* updated schemas, fixed tests, skipping flow tests for now

* added validator for rjsf, hook form via standard schema

* removed @sinclair/typebox

* remove unneeded vite dep

* fix jsonv literal on Field.tsx

* fix schema import path

* fix schema modals

* fix schema modals

* fix json field form, replaced auth form

* initial waku

* finalize waku example

* fix jsonv-ts version

* fix schema updates with falsy values

* fix media api to respect options' init, improve types

* checking media controller test

* checking media controller test

* checking media controller test

* clean up mediacontroller test

* added cookie option `partitioned`, as well as cors `origin` to be array, option to enable `credentials` (#214)

* added cookie option `partitioned`, as well as cors `origin` to be array, option to enable `credentials`

* fix server test

* fix data api (updated jsonv-ts)

* enhance cloudflare image optimization plugin with new options and explain endpoint (#215)

* feat: add ability to serve static by using dynamic imports (#197)

* feat: add ability to serve static by using dynamic imports

* serveStaticViaImport: make manifest optional

* serveStaticViaImport: add error log

* refactor/imports (#217)

* refactored core and core/utils imports

* refactored core and core/utils imports

* refactored media imports

* refactored auth imports

* refactored data imports

* updated package json exports, fixed mm config

* fix tests

* feat/deno (#219)

* update bun version

* fix module manager's em reference

* add basic deno example

* finalize

* docs: fumadocs migration (#185)

* feat(docs): initialize documentation structure with Fumadocs

* feat(docs): remove home route and move /docs route to /route

* feat(docs): add redirect to /start page

* feat(docs): migrate Getting Started chapters

* feat(docs): migrate Usage and Extending chapters

* feat(callout): add CalloutCaution, CalloutDanger, CalloutInfo, and CalloutPositive

* feat(layout): add Discord and GitHub links to documentation layout

* feat(docs): add integration chapters draft

* feat(docs): add modules chapters draft

* refactor(mdx-components): remove unused Icon import

* refactor(StackBlitz): enhance type safety by using unknown instead of any

* refactor(layout): update navigation mode to 'top' in layout configuration

* feat(docs): add @iconify/react package

* docs(mdx-components): add Icon component to MDX components list

* feat(docs): update Next.js integration guide

* feat(docs): update React Router integration guide

* feat(docs): update Astro integration guide

* feat(docs): update Vite integration guide

* fix(docs): update package manager initialization commands

* feat(docs): migrate Modules chapters

* chore(docs): update package.json with new devDependencies

* feat(docs): migrate Integration Runtimes chapters

* feat(docs): update Database usage chapter

* feat(docs): restructure documentation paths

* chore(docs): clean up unused imports and files in documentation

* style(layout): revert navigation mode to previous state

* fix(docs): routing for documentation structure

* feat(openapi): add API documentation generation from OpenAPI schema

* feat(docs): add icons to documentation pages

* chore(dependencies): remove unused content-collections packages

* fix(types): fix type error for attachFile in source.ts

* feat(redirects): update root redirect destination to '/start'

* feat(search): add static search functionality

* chore(dependencies): update fumadocs-core and fumadocs-ui to latest versions

* feat(search): add Powered by Orama link

* feat(generate-openapi): add error handling for missing OpenAPI schema

* feat(scripts): add OpenAPI generation to build process

* feat(config): enable dynamic redirects and rewrites in development mode

* feat(layout): add GitHub token support for improved API rate limits

* feat(redirects): add 301 redirects for cloudflare pages

* feat(docs): add Vercel redirects configuration

* feat(config): enable standalone output for development environment

* chore(layout): adjust layout settings

* refactor(package): clean up ajv dependency versions

* feat(docs): add twoslash support

* refactor(layout): update DocsLayout import and navigation configuration

* chore(layout): clean up layout.tsx by commenting out GithubInfo

* fix(Search): add locale to search initialization

* chore(package): update fumadocs and orama to latest versions

* docs: add menu items descriptions

* feat(layout): add GitHub URL to the layout component

* feat(docs): add AutoTypeTable component to MDX components

* feat(app): implement AutoTypeTable rendering for AppEvents type

* docs(layout): switch callouts back to default components

* fix(config): use __filename and __dirname for module paths

* docs: add note about node.js 22 requirement

* feat(styles): add custom color variables for light and dark themes

* docs: add S3 setup instructions for media module

* docs: fix typos and indentation in media module docs

* docs: add local media adapter example for Node.js

* docs(media): add S3/R2 URL format examples and fix typo

* docs: add cross-links to initial config and seeding sections

* indent numbered lists content, clarified media serve locations

* fix mediacontroller tests

* feat(layout): add AnimatedGridPattern component for dynamic background

* style(layout): configure fancy ToC style ('clerk')

* fix(AnimatedGridPattern): correct strokeDasharray type

* docs: actualize docs

* feat: add favicon

* style(cloudflare): format code examples

* feat(layout): add Github and Discord footer icons

* feat(footer): add SVG social media icons for GitHub and Discord

* docs: adjusted auto type table, added llm functions

* added static deployment to cloudflare workers

* docs: change cf redirects to proxy *.mdx instead of redirecting

---------

Co-authored-by: dswbx <dennis.senn@gmx.ch>
Co-authored-by: cameronapak <cameronandrewpak@gmail.com>

* build: improve build script

* add missing exports, fix EntityTypescript imports

* media: Dropzone: add programmatic upload, additional events, loading state

* schema object: disable extended defaults to allow empty config values

* Feat/new docs deploy (#224)

* test

* try fixing pm

* try fixing pm

* fix docs on imports, export events correctly

---------

Co-authored-by: Tim Seriakov <59409712+timseriakov@users.noreply.github.com>
Co-authored-by: cameronapak <cameronandrewpak@gmail.com>

app/src/core/drivers/email/index.ts

@@ -6,23 +6,3 @@ export interface IEmailDriver<Data = unknown, Options = object> {
       options?: Options,
    ): Promise<Data>;
 }
-
-import type { BkndConfig } from "bknd";
-import { resendEmail, memoryCache } from "bknd/core";
-
-export default {
-   onBuilt: async (app) => {
-      app.server.get("/send-email", async (c) => {
-         if (await app.drivers?.email?.send("test@test.com", "Test", "Test")) {
-            return c.text("success");
-         }
-         return c.text("failed");
-      });
-   },
-   options: {
-      drivers: {
-         email: resendEmail({ apiKey: "..." }),
-         cache: memoryCache(),
-      },
-   },
-} as const satisfies BkndConfig;

app/src/core/index.ts

@@ -1,48 +0,0 @@
-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";
-export { AwsClient } from "./clients/aws/AwsClient";
-export {
-   SimpleRenderer,
-   type TemplateObject,
-   type TemplateTypes,
-   type SimpleRendererOptions,
-} from "./template/SimpleRenderer";
-export { SchemaObject } from "./object/SchemaObject";
-export { DebugLogger } from "./utils/DebugLogger";
-export { Permission } from "./security/Permission";
-export {
-   exp,
-   makeValidator,
-   type FilterQuery,
-   type Primitive,
-   isPrimitive,
-   type TExpression,
-   type BooleanLike,
-   isBooleanLike,
-} from "./object/query/query";
-export { Registry, type Constructor } from "./registry/Registry";
-export { getFlashMessage } from "./server/flash";
-export {
-   s,
-   parse,
-   jsc,
-   describeRoute,
-   schemaToSpec,
-   openAPISpecs,
-   type ParseOptions,
-   InvalidSchemaError,
-} from "./object/schema";
-
-export * from "./drivers";
-export * from "./events";
-
-// compatibility
-export type Middleware = MiddlewareHandler<any, any, any>;
-export interface ClassController {
-   getController: () => Hono<any, any, any>;
-   getMiddleware?: MiddlewareHandler<any, any, any>;
-}

app/src/core/object/SchemaObject.ts

@@ -1,62 +1,61 @@
 import { get, has, omit, set } from "lodash-es";
-import {
-   Default,
-   type Static,
-   type TObject,
-   getFullPathKeys,
-   mergeObjectWith,
-   parse,
-   stripMark,
-} from "../utils";
+import { type s, parse, stripMark, getFullPathKeys, mergeObjectWith, deepFreeze } from "bknd/utils";
 
-export type SchemaObjectOptions<Schema extends TObject> = {
-   onUpdate?: (config: Static<Schema>) => void | Promise<void>;
+export type SchemaObjectOptions<Schema extends s.Schema> = {
+   onUpdate?: (config: s.Static<Schema>) => void | Promise<void>;
    onBeforeUpdate?: (
-      from: Static<Schema>,
-      to: Static<Schema>,
-   ) => Static<Schema> | Promise<Static<Schema>>;
+      from: s.Static<Schema>,
+      to: s.Static<Schema>,
+   ) => s.Static<Schema> | Promise<s.Static<Schema>>;
    restrictPaths?: string[];
    overwritePaths?: (RegExp | string)[];
    forceParse?: boolean;
 };
 
-export class SchemaObject<Schema extends TObject> {
-   private readonly _default: Partial<Static<Schema>>;
-   private _value: Static<Schema>;
-   private _config: Static<Schema>;
+type TSchema = s.ObjectSchema<any>;
+
+export class SchemaObject<Schema extends TSchema = TSchema> {
+   private readonly _default: Partial<s.Static<Schema>>;
+   private _value: s.Static<Schema>;
+   private _config: s.Static<Schema>;
    private _restriction_bypass: boolean = false;
 
    constructor(
       private _schema: Schema,
-      initial?: Partial<Static<Schema>>,
+      initial?: Partial<s.Static<Schema>>,
       private options?: SchemaObjectOptions<Schema>,
    ) {
-      this._default = Default(_schema, {} as any) as any;
-      this._value = initial
-         ? parse(_schema, structuredClone(initial as any), {
-              forceParse: this.isForceParse(),
-              skipMark: this.isForceParse(),
-           })
-         : this._default;
-      this._config = Object.freeze(this._value);
+      this._default = deepFreeze(_schema.template({}, { withOptional: true }) as any);
+      this._value = deepFreeze(
+         parse(_schema, structuredClone(initial ?? {}), {
+            withDefaults: true,
+            //withExtendedDefaults: true,
+            forceParse: this.isForceParse(),
+            skipMark: this.isForceParse(),
+         }),
+      );
+      this._config = deepFreeze(this._value);
    }
 
    protected isForceParse(): boolean {
       return this.options?.forceParse ?? true;
    }
 
-   default(): Static<Schema> {
+   default() {
       return this._default;
    }
 
-   private async onBeforeUpdate(from: Static<Schema>, to: Static<Schema>): Promise<Static<Schema>> {
+   private async onBeforeUpdate(
+      from: s.Static<Schema>,
+      to: s.Static<Schema>,
+   ): Promise<s.Static<Schema>> {
       if (this.options?.onBeforeUpdate) {
          return this.options.onBeforeUpdate(from, to);
       }
       return to;
    }
 
-   get(options?: { stripMark?: boolean }): Static<Schema> {
+   get(options?: { stripMark?: boolean }): s.Static<Schema> {
       if (options?.stripMark) {
          return stripMark(this._config);
       }
@@ -68,8 +67,9 @@ export class SchemaObject<Schema extends TObject> {
       return structuredClone(this._config);
    }
 
-   async set(config: Static<Schema>, noEmit?: boolean): Promise<Static<Schema>> {
+   async set(config: s.Static<Schema>, noEmit?: boolean): Promise<s.Static<Schema>> {
       const valid = parse(this._schema, structuredClone(config) as any, {
+         coerce: false,
          forceParse: true,
          skipMark: this.isForceParse(),
       });
@@ -77,8 +77,8 @@ export class SchemaObject<Schema extends TObject> {
       // regardless of "noEmit" – this should always be triggered
       const updatedConfig = await this.onBeforeUpdate(this._config, valid);
 
-      this._value = updatedConfig;
-      this._config = Object.freeze(updatedConfig);
+      this._value = deepFreeze(updatedConfig);
+      this._config = deepFreeze(updatedConfig);
 
       if (noEmit !== true) {
          await this.options?.onUpdate?.(this._config);
@@ -118,9 +118,9 @@ export class SchemaObject<Schema extends TObject> {
       return;
    }
 
-   async patch(path: string, value: any): Promise<[Partial<Static<Schema>>, Static<Schema>]> {
+   async patch(path: string, value: any): Promise<[Partial<s.Static<Schema>>, s.Static<Schema>]> {
       const current = this.clone();
-      const partial = path.length > 0 ? (set({}, path, value) as Partial<Static<Schema>>) : value;
+      const partial = path.length > 0 ? (set({}, path, value) as Partial<s.Static<Schema>>) : value;
 
       this.throwIfRestricted(partial);
 
@@ -168,9 +168,12 @@ export class SchemaObject<Schema extends TObject> {
       return [partial, newConfig];
    }
 
-   async overwrite(path: string, value: any): Promise<[Partial<Static<Schema>>, Static<Schema>]> {
+   async overwrite(
+      path: string,
+      value: any,
+   ): Promise<[Partial<s.Static<Schema>>, s.Static<Schema>]> {
       const current = this.clone();
-      const partial = path.length > 0 ? (set({}, path, value) as Partial<Static<Schema>>) : value;
+      const partial = path.length > 0 ? (set({}, path, value) as Partial<s.Static<Schema>>) : value;
 
       this.throwIfRestricted(partial);
 
@@ -194,7 +197,7 @@ export class SchemaObject<Schema extends TObject> {
       return has(this._config, path);
    }
 
-   async remove(path: string): Promise<[Partial<Static<Schema>>, Static<Schema>]> {
+   async remove(path: string): Promise<[Partial<s.Static<Schema>>, s.Static<Schema>]> {
       this.throwIfRestricted(path);
 
       if (!this.has(path)) {
@@ -202,9 +205,9 @@ export class SchemaObject<Schema extends TObject> {
       }
 
       const current = this.clone();
-      const removed = get(current, path) as Partial<Static<Schema>>;
+      const removed = get(current, path) as Partial<s.Static<Schema>>;
       const config = omit(current, path);
-      const newConfig = await this.set(config);
+      const newConfig = await this.set(config as any);
       return [removed, newConfig];
    }
 }

app/src/core/object/query/query.ts

@@ -1,4 +1,4 @@
-import type { PrimaryFieldType } from "core";
+import type { PrimaryFieldType } from "core/config";
 
 export type Primitive = PrimaryFieldType | string | number | boolean;
 export function isPrimitive(value: any): value is Primitive {

app/src/core/object/schema/index.ts

@@ -1,52 +0,0 @@
-import { mergeObject } from "core/utils";
-
-//export { jsc, type Options, type Hook } from "./validator";
-import * as s from "jsonv-ts";
-
-export { validator as jsc, type Options } from "jsonv-ts/hono";
-export { describeRoute, schemaToSpec, openAPISpecs } from "jsonv-ts/hono";
-
-export { s };
-
-export class InvalidSchemaError extends Error {
-   constructor(
-      public schema: s.TAnySchema,
-      public value: unknown,
-      public errors: s.ErrorDetail[] = [],
-   ) {
-      super(
-         `Invalid schema given for ${JSON.stringify(value, null, 2)}\n\n` +
-            `Error: ${JSON.stringify(errors[0], null, 2)}`,
-      );
-   }
-}
-
-export type ParseOptions = {
-   withDefaults?: boolean;
-   coerse?: boolean;
-   clone?: boolean;
-};
-
-export const cloneSchema = <S extends s.TSchema>(schema: S): S => {
-   const json = schema.toJSON();
-   return s.fromSchema(json) as S;
-};
-
-export function parse<S extends s.TAnySchema>(
-   _schema: S,
-   v: unknown,
-   opts: ParseOptions = {},
-): s.StaticCoerced<S> {
-   const schema = (opts.clone ? cloneSchema(_schema as any) : _schema) as s.TSchema;
-   const value = opts.coerse !== false ? schema.coerce(v) : v;
-   const result = schema.validate(value, {
-      shortCircuit: true,
-      ignoreUnsupported: true,
-   });
-   if (!result.valid) throw new InvalidSchemaError(schema, v, result.errors);
-   if (opts.withDefaults) {
-      return mergeObject(schema.template({ withOptional: true }), value) as any;
-   }
-
-   return value as any;
-}

app/src/core/object/schema/validator.ts

@@ -1,63 +0,0 @@
-import type { Context, Env, Input, MiddlewareHandler, ValidationTargets } from "hono";
-import { validator as honoValidator } from "hono/validator";
-import type { Static, StaticCoerced, TAnySchema } from "jsonv-ts";
-
-export type Options = {
-   coerce?: boolean;
-   includeSchema?: boolean;
-};
-
-type ValidationResult = {
-   valid: boolean;
-   errors: {
-      keywordLocation: string;
-      instanceLocation: string;
-      error: string;
-      data?: unknown;
-   }[];
-};
-
-export type Hook<T, E extends Env, P extends string> = (
-   result: { result: ValidationResult; data: T },
-   c: Context<E, P>,
-) => Response | Promise<Response> | void;
-
-export const validator = <
-   // @todo: somehow hono prevents the usage of TSchema
-   Schema extends TAnySchema,
-   Target extends keyof ValidationTargets,
-   E extends Env,
-   P extends string,
-   Opts extends Options = Options,
-   Out = Opts extends { coerce: false } ? Static<Schema> : StaticCoerced<Schema>,
-   I extends Input = {
-      in: { [K in Target]: Static<Schema> };
-      out: { [K in Target]: Out };
-   },
->(
-   target: Target,
-   schema: Schema,
-   options?: Opts,
-   hook?: Hook<Out, E, P>,
-): MiddlewareHandler<E, P, I> => {
-   // @ts-expect-error not typed well
-   return honoValidator(target, async (_value, c) => {
-      const value = options?.coerce !== false ? schema.coerce(_value) : _value;
-      // @ts-ignore
-      const result = schema.validate(value);
-      if (!result.valid) {
-         return c.json({ ...result, schema }, 400);
-      }
-
-      if (hook) {
-         const hookResult = hook({ result, data: value as Out }, c);
-         if (hookResult) {
-            return hookResult;
-         }
-      }
-
-      return value as Out;
-   });
-};
-
-export const jsc = validator;

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/template/SimpleRenderer.spec.ts

@@ -1,5 +1,5 @@
 import { describe, expect, test } from "bun:test";
-import { SimpleRenderer } from "core";
+import { SimpleRenderer } from "./SimpleRenderer";
 
 describe(SimpleRenderer, () => {
    const renderer = new SimpleRenderer(

app/src/core/utils/console.ts

@@ -1,6 +1,6 @@
-import { datetimeStringLocal } from "core/utils";
+import { datetimeStringLocal } from "./dates";
 import colors from "picocolors";
-import { env } from "core";
+import { env } from "core/env";
 
 function hasColors() {
    try {

app/src/core/utils/index.ts

@@ -6,12 +6,25 @@ export * from "./perf";
 export * from "./file";
 export * from "./reqres";
 export * from "./xml";
-export type { Prettify, PrettifyRec } from "./types";
-export * from "./typebox";
+export type { Prettify, PrettifyRec, RecursivePartial } from "./types";
 export * from "./dates";
 export * from "./crypto";
 export * from "./uuid";
-export { FromSchema } from "./typebox/from-schema";
 export * from "./test";
 export * from "./runtime";
 export * from "./numbers";
+export {
+   s,
+   stripMark,
+   mark,
+   stringIdentifier,
+   SecretSchema,
+   secret,
+   parse,
+   jsc,
+   describeRoute,
+   schemaToSpec,
+   openAPISpecs,
+   type ParseOptions,
+   InvalidSchemaError,
+} from "./schema";

app/src/core/utils/objects.ts

@@ -94,16 +94,14 @@ export function transformObject<T extends Record<string, any>, U>(
    object: T,
    transform: (value: T[keyof T], key: keyof T) => U | undefined,
 ): { [K in keyof T]: U } {
-   return Object.entries(object).reduce(
-      (acc, [key, value]) => {
-         const t = transform(value, key as keyof T);
-         if (typeof t !== "undefined") {
-            acc[key as keyof T] = t;
-         }
-         return acc;
-      },
-      {} as { [K in keyof T]: U },
-   );
+   const result = {} as { [K in keyof T]: U };
+   for (const [key, value] of Object.entries(object) as [keyof T, T[keyof T]][]) {
+      const t = transform(value, key);
+      if (typeof t !== "undefined") {
+         result[key] = t;
+      }
+   }
+   return result;
 }
 export const objectTransform = transformObject;
 
@@ -419,3 +417,21 @@ export function pick<T extends object, K extends keyof T>(obj: T, keys: K[]): Pi
       {} as Pick<T, K>,
    );
 }
+
+export function deepFreeze<T extends object>(object: T): T {
+   if (Object.isFrozen(object)) return object;
+
+   // Retrieve the property names defined on object
+   const propNames = Reflect.ownKeys(object);
+
+   // Freeze properties before freezing self
+   for (const name of propNames) {
+      const value = object[name];
+
+      if ((value && typeof value === "object") || typeof value === "function") {
+         deepFreeze(value);
+      }
+   }
+
+   return Object.freeze(object);
+}

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

@@ -0,0 +1,87 @@
+import * as s from "jsonv-ts";
+
+export { validator as jsc, type Options } from "jsonv-ts/hono";
+export { describeRoute, schemaToSpec, openAPISpecs } from "jsonv-ts/hono";
+
+export { secret, SecretSchema } from "./secret";
+
+export { s };
+
+export const stripMark = <O extends object>(o: O): O => o;
+export const mark = <O extends object>(o: O): O => o;
+
+export const stringIdentifier = s.string({
+   pattern: "^[a-zA-Z_][a-zA-Z0-9_]*$",
+   minLength: 2,
+   maxLength: 150,
+});
+
+export class InvalidSchemaError extends Error {
+   constructor(
+      public schema: s.Schema,
+      public value: unknown,
+      public errors: s.ErrorDetail[] = [],
+   ) {
+      super(
+         `Invalid schema given for ${JSON.stringify(value, null, 2)}\n\n` +
+            `Error: ${JSON.stringify(errors[0], null, 2)}`,
+      );
+   }
+
+   first() {
+      return this.errors[0]!;
+   }
+
+   firstToString() {
+      const first = this.first();
+      return `${first.error} at ${first.instanceLocation}`;
+   }
+}
+
+export type ParseOptions = {
+   withDefaults?: boolean;
+   withExtendedDefaults?: boolean;
+   coerce?: boolean;
+   coerceDropUnknown?: boolean;
+   clone?: boolean;
+   skipMark?: boolean; // @todo: do something with this
+   forceParse?: boolean; // @todo: do something with this
+   onError?: (errors: s.ErrorDetail[]) => void;
+};
+
+export const cloneSchema = <S extends s.Schema>(schema: S): S => {
+   const json = schema.toJSON();
+   return s.fromSchema(json) as S;
+};
+
+export function parse<S extends s.Schema, Options extends ParseOptions = ParseOptions>(
+   _schema: S,
+   v: unknown,
+   opts?: Options,
+): Options extends { coerce: true } ? s.StaticCoerced<S> : s.Static<S> {
+   const schema = (opts?.clone ? cloneSchema(_schema as any) : _schema) as s.Schema;
+   let value =
+      opts?.coerce !== false
+         ? schema.coerce(v, { dropUnknown: opts?.coerceDropUnknown ?? false })
+         : v;
+   if (opts?.withDefaults !== false) {
+      value = schema.template(value, {
+         withOptional: true,
+         withExtendedOptional: opts?.withExtendedDefaults ?? false,
+      });
+   }
+
+   const result = _schema.validate(value, {
+      shortCircuit: true,
+      ignoreUnsupported: true,
+   });
+   if (!result.valid) {
+      if (opts?.onError) {
+         opts.onError(result.errors);
+      } else {
+         throw new InvalidSchemaError(schema, v, result.errors);
+      }
+   }
+
+   return value as any;
+}

app/src/core/utils/schema/secret.ts

@@ -0,0 +1,6 @@
+import { StringSchema, type IStringOptions } from "jsonv-ts";
+
+export class SecretSchema<O extends IStringOptions> extends StringSchema<O> {}
+
+export const secret = <O extends IStringOptions>(o?: O): SecretSchema<O> & O =>
+   new SecretSchema(o) as any;

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,201 +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";
-
-export type RecursivePartial<T> = {
-   [P in keyof T]?: T[P] extends (infer U)[]
-      ? RecursivePartial<U>[]
-      : T[P] extends object | undefined
-        ? RecursivePartial<T[P]>
-        : T[P];
-};
-
-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 };

app/src/core/utils/types.d.ts

@@ -6,3 +6,11 @@ export type Prettify<T> = {
 export type PrettifyRec<T> = {
    [K in keyof T]: T[K] extends object ? Prettify<T[K]> : T[K];
 } & NonNullable<unknown>;
+
+export type RecursivePartial<T> = {
+   [P in keyof T]?: T[P] extends (infer U)[]
+      ? RecursivePartial<U>[]
+      : T[P] extends object | undefined
+        ? RecursivePartial<T[P]>
+        : T[P];
+};