changed tb imports

app/src/adapter/cloudflare/storage/StorageR2Adapter.ts

@@ -1,8 +1,10 @@
 import { registries } from "bknd";
 import { isDebug } from "bknd/core";
-import { StringEnum, Type } from "bknd/utils";
+import { StringEnum } from "bknd/utils";
 import { guessMimeType as guess, StorageAdapter, type FileBody } from "bknd/media";
 import { getBindings } from "../bindings";
+import * as tb from "@sinclair/typebox";
+const { Type } = tb;
 
 export function makeSchema(bindings: string[] = []) {
    return Type.Object(

app/src/adapter/node/storage/StorageLocalAdapter.ts

@@ -1,7 +1,9 @@
 import { readFile, readdir, stat, unlink, writeFile } from "node:fs/promises";
-import { type Static, Type, isFile, parse } from "bknd/utils";
+import { type Static, isFile, parse } from "bknd/utils";
 import type { FileBody, FileListObject, FileMeta, FileUploadPayload } from "bknd/media";
 import { StorageAdapter, guessMimeType as guess } from "bknd/media";
+import * as tb from "@sinclair/typebox";
+const { Type } = tb;
 
 export const localAdapterConfig = Type.Object(
    {

app/src/auth/api/AuthController.ts

@@ -1,9 +1,11 @@
 import { type AppAuth, AuthPermissions, type SafeUser, type Strategy } from "auth";
 import { tbValidator as tb } from "core";
-import { Type, TypeInvalidError, parse, transformObject } from "core/utils";
+import { TypeInvalidError, parse, transformObject } from "core/utils";
 import { DataPermissions } from "data";
 import type { Hono } from "hono";
 import { Controller, type ServerEnv } from "modules/Controller";
+import * as tbbox from "@sinclair/typebox";
+const { Type } = tbbox;
 
 export type AuthActionResponse = {
    success: boolean;

app/src/auth/auth-schema.ts

@@ -1,6 +1,8 @@
 import { cookieConfig, jwtConfig } from "auth/authenticate/Authenticator";
 import { CustomOAuthStrategy, OAuthStrategy, PasswordStrategy } from "auth/authenticate/strategies";
-import { type Static, StringRecord, Type, objectTransform } from "core/utils";
+import { type Static, StringRecord, objectTransform } from "core/utils";
+import * as tbbox from "@sinclair/typebox";
+const { Type } = tbbox;
 
 export const Strategies = {
    password: {

app/src/auth/authenticate/Authenticator.ts

@@ -1,20 +1,14 @@
 import { type DB, Exception, type PrimaryFieldType } from "core";
 import { addFlashMessage } from "core/server/flash";
-import {
-   type Static,
-   StringEnum,
-   type TObject,
-   Type,
-   parse,
-   runtimeSupports,
-   transformObject,
-} from "core/utils";
+import { type Static, StringEnum, type TObject, parse, runtimeSupports } from "core/utils";
 import type { Context, Hono } from "hono";
 import { deleteCookie, getSignedCookie, setSignedCookie } from "hono/cookie";
 import { sign, verify } from "hono/jwt";
 import type { CookieOptions } from "hono/utils/cookie";
 import type { ServerEnv } from "modules/Controller";
 import { pick } from "lodash-es";
+import * as tbbox from "@sinclair/typebox";
+const { Type } = tbbox;
 
 type Input = any; // workaround
 export type JWTPayload = Parameters<typeof sign>[0];

app/src/auth/authenticate/strategies/PasswordStrategy.ts

@@ -1,9 +1,11 @@
 import type { Authenticator, Strategy } from "auth";
-import { isDebug, tbValidator as tb } from "core";
-import { type Static, StringEnum, Type, parse } from "core/utils";
+import { tbValidator as tb } from "core";
+import { type Static, StringEnum, parse } from "core/utils";
 import { hash } from "core/utils";
-import { type Context, Hono } from "hono";
-import { type StrategyAction, type StrategyActions, createStrategyAction } from "../Authenticator";
+import { Hono } from "hono";
+import { type StrategyActions, createStrategyAction } from "../Authenticator";
+import * as tbbox from "@sinclair/typebox";
+const { Type } = tbbox;
 
 type LoginSchema = { username: string; password: string } | { email: string; password: string };
 type RegisterSchema = { email: string; password: string; [key: string]: any };

app/src/auth/authenticate/strategies/oauth/CustomOAuthStrategy.ts

@@ -1,6 +1,8 @@
-import { type Static, StringEnum, Type } from "core/utils";
+import { type Static, StringEnum } from "core/utils";
+import * as tbbox from "@sinclair/typebox";
 import type * as oauth from "oauth4webapi";
 import { OAuthStrategy } from "./OAuthStrategy";
+const { Type } = tbbox;
 
 type SupportedTypes = "oauth2" | "oidc";
 

app/src/auth/authenticate/strategies/oauth/OAuthStrategy.ts

@@ -1,10 +1,12 @@
 import type { AuthAction, Authenticator, Strategy } from "auth";
 import { Exception, isDebug } from "core";
-import { type Static, StringEnum, type TSchema, Type, filterKeys, parse } from "core/utils";
+import { type Static, StringEnum, filterKeys } from "core/utils";
 import { type Context, Hono } from "hono";
 import { getSignedCookie, setSignedCookie } from "hono/cookie";
 import * as oauth from "oauth4webapi";
 import * as issuers from "./issuers";
+import * as tbbox from "@sinclair/typebox";
+const { Type } = tbbox;
 
 type ConfiguredIssuers = keyof typeof issuers;
 type SupportedTypes = "oauth2" | "oidc";

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

@@ -1,18 +1,11 @@
-import {
-   Kind,
-   type ObjectOptions,
-   type SchemaOptions,
-   type Static,
-   type StaticDecode,
-   type StringOptions,
-   type TLiteral,
-   type TLiteralValue,
-   type TObject,
-   type TRecord,
-   type TSchema,
-   type TString,
-   Type,
+import * as tb from "@sinclair/typebox";
+import type {
    TypeRegistry,
+   Static,
+   StaticDecode,
+   TSchema,
+   SchemaOptions,
+   TObject,
 } from "@sinclair/typebox";
 import {
    DefaultErrorFunction,
@@ -43,7 +36,7 @@ const validationSymbol = Symbol("tb-parse-validation");
 export class TypeInvalidError extends Error {
    errors: ValueError[];
    constructor(
-      public schema: TSchema,
+      public schema: tb.TSchema,
       public data: unknown,
       message?: string,
    ) {
@@ -92,25 +85,25 @@ export function mark(obj: any, validated = true) {
    }
 }
 
-export function parse<Schema extends TSchema = TSchema>(
+export function parse<Schema extends tb.TSchema = tb.TSchema>(
    schema: Schema,
-   data: RecursivePartial<Static<Schema>>,
+   data: RecursivePartial<tb.Static<Schema>>,
    options?: ParseOptions,
-): Static<Schema> {
+): tb.Static<Schema> {
    if (!options?.forceParse && typeof data === "object" && validationSymbol in data) {
       if (options?.useDefaults === false) {
-         return data as Static<typeof schema>;
+         return data as tb.Static<typeof schema>;
       }
 
       // this is important as defaults are expected
-      return Default(schema, data as any) as Static<Schema>;
+      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 Static<typeof schema>;
+      return parsed as tb.Static<typeof schema>;
    } else if (options?.onError) {
       options.onError(Errors(schema, data));
    } else {
@@ -122,26 +115,26 @@ export function parse<Schema extends TSchema = TSchema>(
    return undefined as any;
 }
 
-export function parseDecode<Schema extends TSchema = TSchema>(
+export function parseDecode<Schema extends tb.TSchema = tb.TSchema>(
    schema: Schema,
-   data: RecursivePartial<StaticDecode<Schema>>,
-): StaticDecode<Schema> {
+   data: RecursivePartial<tb.StaticDecode<Schema>>,
+): tb.StaticDecode<Schema> {
    //console.log("parseDecode", schema, data);
    const parsed = Default(schema, data);
 
    if (Check(schema, parsed)) {
-      return parsed as StaticDecode<typeof schema>;
+      return parsed as tb.StaticDecode<typeof schema>;
    }
    //console.log("errors", ...Errors(schema, data));
 
    throw new TypeInvalidError(schema, data);
 }
 
-export function strictParse<Schema extends TSchema = TSchema>(
+export function strictParse<Schema extends tb.TSchema = tb.TSchema>(
    schema: Schema,
-   data: Static<Schema>,
+   data: tb.Static<Schema>,
    options?: ParseOptions,
-): Static<Schema> {
+): tb.Static<Schema> {
    return parse(schema, data as any, options);
 }
 
@@ -150,11 +143,14 @@ export function registerCustomTypeboxKinds(registry: typeof TypeRegistry) {
       return typeof value === "string" && schema.enum.includes(value);
    });
 }
-registerCustomTypeboxKinds(TypeRegistry);
+registerCustomTypeboxKinds(tb.TypeRegistry);
 
-export const StringEnum = <const T extends readonly string[]>(values: T, options?: StringOptions) =>
-   Type.Unsafe<T[number]>({
-      [Kind]: "StringEnum",
+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,
@@ -162,17 +158,25 @@ export const StringEnum = <const T extends readonly string[]>(values: T, 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 TSchema>(properties: T, options?: ObjectOptions) =>
-   Type.Object({}, { ...options, additionalProperties: properties }) as unknown as TRecord<
-      TString,
+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 TLiteralValue = TLiteralValue>(value: T, options?: SchemaOptions) =>
-   Type.Literal(value, { ...options, default: value, const: value, readOnly: true }) as TLiteral<T>;
+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 = Type.String({
+export const StringIdentifier = tb.Type.String({
    pattern: "^[a-zA-Z_][a-zA-Z0-9_]*$",
    minLength: 2,
    maxLength: 150,
@@ -183,24 +187,13 @@ SetErrorFunction((error) => {
       return error.schema.errorMessage;
    }
 
-   if (error?.schema?.[Kind] === "StringEnum") {
+   if (error?.schema?.[tb.Kind] === "StringEnum") {
       return `Expected: ${error.schema.enum.map((e) => `"${e}"`).join(", ")}`;
    }
 
    return DefaultErrorFunction(error);
 });
 
-export {
-   Type,
-   type Static,
-   type StaticDecode,
-   type TSchema,
-   Kind,
-   type TObject,
-   type ValueError,
-   type SchemaOptions,
-   Value,
-   Default,
-   Errors,
-   Check,
-};
+export type { Static, StaticDecode, TSchema, TObject, ValueError, SchemaOptions };
+
+export { Value, Default, Errors, Check };

app/src/data/api/DataController.ts

@@ -1,5 +1,6 @@
 import { isDebug, tbValidator as tb } from "core";
-import { StringEnum, Type } from "core/utils";
+import { StringEnum } from "core/utils";
+import * as tbbox from "@sinclair/typebox";
 import {
    DataPermissions,
    type EntityData,
@@ -14,6 +15,7 @@ import type { ModuleBuildContext } from "modules";
 import { Controller } from "modules/Controller";
 import * as SystemPermissions from "modules/permissions";
 import type { AppDataConfig } from "../data-schema";
+const { Type } = tbbox;
 
 export class DataController extends Controller {
    constructor(

app/src/data/data-schema.ts

@@ -1,4 +1,5 @@
-import { type Static, StringRecord, Type, objectTransform } from "core/utils";
+import { type Static, StringRecord, objectTransform } from "core/utils";
+import * as tb from "@sinclair/typebox";
 import {
    FieldClassMap,
    RelationClassMap,
@@ -18,36 +19,38 @@ export type FieldType = keyof typeof FIELDS;
 export const RELATIONS = RelationClassMap;
 
 export const fieldsSchemaObject = objectTransform(FIELDS, (field, name) => {
-   return Type.Object(
+   return tb.Type.Object(
       {
-         type: Type.Const(name, { default: name, readOnly: true }),
-         config: Type.Optional(field.schema),
+         type: tb.Type.Const(name, { default: name, readOnly: true }),
+         config: tb.Type.Optional(field.schema),
       },
       {
          title: name,
       },
    );
 });
-export const fieldsSchema = Type.Union(Object.values(fieldsSchemaObject));
+export const fieldsSchema = tb.Type.Union(Object.values(fieldsSchemaObject));
 export const entityFields = StringRecord(fieldsSchema);
 export type TAppDataField = Static<typeof fieldsSchema>;
 export type TAppDataEntityFields = Static<typeof entityFields>;
 
-export const entitiesSchema = Type.Object({
+export const entitiesSchema = tb.Type.Object({
    //name: Type.String(),
-   type: Type.Optional(Type.String({ enum: entityTypes, default: "regular", readOnly: true })),
-   config: Type.Optional(entityConfigSchema),
-   fields: Type.Optional(entityFields),
+   type: tb.Type.Optional(
+      tb.Type.String({ enum: entityTypes, default: "regular", readOnly: true }),
+   ),
+   config: tb.Type.Optional(entityConfigSchema),
+   fields: tb.Type.Optional(entityFields),
 });
 export type TAppDataEntity = Static<typeof entitiesSchema>;
 
 export const relationsSchema = Object.entries(RelationClassMap).map(([name, relationClass]) => {
-   return Type.Object(
+   return tb.Type.Object(
       {
-         type: Type.Const(name, { default: name, readOnly: true }),
-         source: Type.String(),
-         target: Type.String(),
-         config: Type.Optional(relationClass.schema),
+         type: tb.Type.Const(name, { default: name, readOnly: true }),
+         source: tb.Type.String(),
+         target: tb.Type.String(),
+         config: tb.Type.Optional(relationClass.schema),
       },
       {
          title: name,
@@ -56,24 +59,24 @@ export const relationsSchema = Object.entries(RelationClassMap).map(([name, rela
 });
 export type TAppDataRelation = Static<(typeof relationsSchema)[number]>;
 
-export const indicesSchema = Type.Object(
+export const indicesSchema = tb.Type.Object(
    {
-      entity: Type.String(),
-      fields: Type.Array(Type.String(), { minItems: 1 }),
+      entity: tb.Type.String(),
+      fields: tb.Type.Array(tb.Type.String(), { minItems: 1 }),
       //name: Type.Optional(Type.String()),
-      unique: Type.Optional(Type.Boolean({ default: false })),
+      unique: tb.Type.Optional(tb.Type.Boolean({ default: false })),
    },
    {
       additionalProperties: false,
    },
 );
 
-export const dataConfigSchema = Type.Object(
+export const dataConfigSchema = tb.Type.Object(
    {
-      basepath: Type.Optional(Type.String({ default: "/api/data" })),
-      entities: Type.Optional(StringRecord(entitiesSchema, { default: {} })),
-      relations: Type.Optional(StringRecord(Type.Union(relationsSchema), { default: {} })),
-      indices: Type.Optional(StringRecord(indicesSchema, { default: {} })),
+      basepath: tb.Type.Optional(tb.Type.String({ default: "/api/data" })),
+      entities: tb.Type.Optional(StringRecord(entitiesSchema, { default: {} })),
+      relations: tb.Type.Optional(StringRecord(tb.Type.Union(relationsSchema), { default: {} })),
+      indices: tb.Type.Optional(StringRecord(indicesSchema, { default: {} })),
    },
    {
       additionalProperties: false,

app/src/data/entities/Entity.ts

@@ -2,12 +2,13 @@ import { config } from "core";
 import {
    type Static,
    StringEnum,
-   Type,
    parse,
    snakeToPascalWithSpaces,
    transformObject,
 } from "core/utils";
 import { type Field, PrimaryField, type TActionContext, type TRenderContext } from "../fields";
+import * as tbbox from "@sinclair/typebox";
+const { Type } = tbbox;
 
 // @todo: entity must be migrated to typebox
 export const entityConfigSchema = Type.Object(

app/src/data/fields/BooleanField.ts

@@ -1,7 +1,9 @@
-import { type Static, Type } from "core/utils";
+import type { Static } from "core/utils";
 import type { EntityManager } from "data";
 import { TransformPersistFailedException } from "../errors";
 import { Field, type TActionContext, type TRenderContext, baseFieldConfigSchema } from "./Field";
+import * as tb from "@sinclair/typebox";
+const { Type } = tb;
 
 export const booleanFieldConfigSchema = Type.Composite([
    Type.Object({

app/src/data/fields/DateField.ts

@@ -1,6 +1,8 @@
-import { type Static, StringEnum, Type, dayjs } from "core/utils";
+import { type Static, StringEnum, dayjs } from "core/utils";
 import type { EntityManager } from "../entities";
 import { Field, type TActionContext, type TRenderContext, baseFieldConfigSchema } from "./Field";
+import * as tbbox from "@sinclair/typebox";
+const { Type } = tbbox;
 
 export const dateFieldConfigSchema = Type.Composite(
    [

app/src/data/fields/EnumField.ts

@@ -1,7 +1,9 @@
-import { Const, type Static, StringEnum, StringRecord, Type } from "core/utils";
+import { Const, type Static, StringEnum } from "core/utils";
 import type { EntityManager } from "data";
 import { TransformPersistFailedException } from "../errors";
 import { Field, type TActionContext, type TRenderContext, baseFieldConfigSchema } from "./Field";
+import * as tbbox from "@sinclair/typebox";
+const { Type } = tbbox;
 
 export const enumFieldConfigSchema = Type.Composite(
    [

app/src/data/fields/Field.ts

@@ -4,13 +4,14 @@ import {
    type Static,
    StringEnum,
    type TSchema,
-   Type,
    TypeInvalidError,
 } from "core/utils";
 import type { HTMLInputTypeAttribute, InputHTMLAttributes } from "react";
 import type { EntityManager } from "../entities";
 import { InvalidFieldConfigException, TransformPersistFailedException } from "../errors";
 import type { FieldSpec } from "data/connection/Connection";
+import * as tbbox from "@sinclair/typebox";
+const { Type } = tbbox;
 
 // @todo: contexts need to be reworked
 // e.g. "table" is irrelevant, because if read is not given, it fails

app/src/data/fields/JsonField.ts

@@ -1,7 +1,9 @@
-import { type Static, Type } from "core/utils";
+import type { Static } from "core/utils";
 import type { EntityManager } from "data";
 import { TransformPersistFailedException } from "../errors";
 import { Field, type TActionContext, type TRenderContext, baseFieldConfigSchema } from "./Field";
+import * as tbbox from "@sinclair/typebox";
+const { Type } = tbbox;
 
 export const jsonFieldConfigSchema = Type.Composite([baseFieldConfigSchema, Type.Object({})]);
 

app/src/data/fields/JsonSchemaField.ts

@@ -1,8 +1,10 @@
 import { type Schema as JsonSchema, Validator } from "@cfworker/json-schema";
-import { Default, FromSchema, type Static, Type } from "core/utils";
+import { Default, FromSchema, type Static } from "core/utils";
 import type { EntityManager } from "data";
 import { TransformPersistFailedException } from "../errors";
 import { Field, type TActionContext, type TRenderContext, baseFieldConfigSchema } from "./Field";
+import * as tbbox from "@sinclair/typebox";
+const { Type } = tbbox;
 
 export const jsonSchemaFieldConfigSchema = Type.Composite(
    [

app/src/data/fields/NumberField.ts

@@ -1,7 +1,9 @@
-import { type Static, Type } from "core/utils";
+import type { Static } from "core/utils";
 import type { EntityManager } from "data";
 import { TransformPersistFailedException } from "../errors";
 import { Field, type TActionContext, type TRenderContext, baseFieldConfigSchema } from "./Field";
+import * as tbbox from "@sinclair/typebox";
+const { Type } = tbbox;
 
 export const numberFieldConfigSchema = Type.Composite(
    [

app/src/data/fields/PrimaryField.ts

@@ -1,6 +1,8 @@
 import { config } from "core";
-import { type Static, Type } from "core/utils";
+import type { Static } from "core/utils";
 import { Field, baseFieldConfigSchema } from "./Field";
+import * as tbbox from "@sinclair/typebox";
+const { Type } = tbbox;
 
 export const primaryFieldConfigSchema = Type.Composite([
    Type.Omit(baseFieldConfigSchema, ["required"]),

app/src/data/fields/TextField.ts

@@ -1,7 +1,9 @@
-import { type Static, Type } from "core/utils";
 import type { EntityManager } from "data";
+import type { Static } from "core/utils";
 import { TransformPersistFailedException } from "../errors";
 import { Field, type TActionContext, baseFieldConfigSchema } from "./Field";
+import * as tb from "@sinclair/typebox";
+const { Type } = tb;
 
 export const textFieldConfigSchema = Type.Composite(
    [

app/src/data/fields/VirtualField.ts

@@ -1,5 +1,7 @@
-import { type Static, Type } from "core/utils";
+import type { Static } from "core/utils";
 import { Field, baseFieldConfigSchema } from "./Field";
+import * as tbbox from "@sinclair/typebox";
+const { Type } = tbbox;
 
 export const virtualFieldConfigSchema = Type.Composite([baseFieldConfigSchema, Type.Object({})]);
 

app/src/data/relations/EntityRelation.ts

@@ -1,4 +1,4 @@
-import { type Static, Type, parse } from "core/utils";
+import { type Static, parse } from "core/utils";
 import type { ExpressionBuilder, SelectQueryBuilder } from "kysely";
 import type { Entity, EntityData, EntityManager } from "../entities";
 import {
@@ -8,6 +8,8 @@ import {
 } from "../relations";
 import type { RepoQuery } from "../server/data-query-impl";
 import type { RelationType } from "./relation-types";
+import * as tbbox from "@sinclair/typebox";
+const { Type } = tbbox;
 
 export type KyselyJsonFrom = any;
 export type KyselyQueryBuilder = SelectQueryBuilder<any, any, any>;

app/src/data/relations/ManyToManyRelation.ts

@@ -1,4 +1,4 @@
-import { type Static, Type } from "core/utils";
+import type { Static } from "core/utils";
 import type { ExpressionBuilder } from "kysely";
 import { Entity, type EntityManager } from "../entities";
 import { type Field, PrimaryField, VirtualField } from "../fields";
@@ -7,6 +7,8 @@ import { EntityRelation, type KyselyJsonFrom, type KyselyQueryBuilder } from "./
 import { EntityRelationAnchor } from "./EntityRelationAnchor";
 import { RelationField } from "./RelationField";
 import { type RelationType, RelationTypes } from "./relation-types";
+import * as tbbox from "@sinclair/typebox";
+const { Type } = tbbox;
 
 export type ManyToManyRelationConfig = Static<typeof ManyToManyRelation.schema>;
 

app/src/data/relations/ManyToOneRelation.ts

@@ -1,6 +1,6 @@
 import type { PrimaryFieldType } from "core";
 import { snakeToPascalWithSpaces } from "core/utils";
-import { type Static, Type } from "core/utils";
+import type { Static } from "core/utils";
 import type { ExpressionBuilder } from "kysely";
 import type { Entity, EntityManager } from "../entities";
 import type { RepoQuery } from "../server/data-query-impl";
@@ -9,6 +9,8 @@ import { EntityRelationAnchor } from "./EntityRelationAnchor";
 import { RelationField, type RelationFieldBaseConfig } from "./RelationField";
 import type { MutationInstructionResponse } from "./RelationMutator";
 import { type RelationType, RelationTypes } from "./relation-types";
+import * as tbbox from "@sinclair/typebox";
+const { Type } = tbbox;
 
 /**
  * Source entity receives the mapping field

app/src/data/relations/PolymorphicRelation.ts

@@ -1,4 +1,4 @@
-import { type Static, Type } from "core/utils";
+import type { Static } from "core/utils";
 import type { ExpressionBuilder } from "kysely";
 import type { Entity, EntityManager } from "../entities";
 import { NumberField, TextField } from "../fields";
@@ -6,6 +6,8 @@ import type { RepoQuery } from "../server/data-query-impl";
 import { EntityRelation, type KyselyJsonFrom, type KyselyQueryBuilder } from "./EntityRelation";
 import { EntityRelationAnchor } from "./EntityRelationAnchor";
 import { type RelationType, RelationTypes } from "./relation-types";
+import * as tbbox from "@sinclair/typebox";
+const { Type } = tbbox;
 
 export type PolymorphicRelationConfig = Static<typeof PolymorphicRelation.schema>;
 

app/src/data/relations/RelationField.ts

@@ -1,8 +1,10 @@
-import { type Static, StringEnum, Type } from "core/utils";
+import { type Static, StringEnum } from "core/utils";
 import type { EntityManager } from "../entities";
 import { Field, baseFieldConfigSchema } from "../fields";
 import type { EntityRelation } from "./EntityRelation";
 import type { EntityRelationAnchor } from "./EntityRelationAnchor";
+import * as tbbox from "@sinclair/typebox";
+const { Type } = tbbox;
 
 const CASCADES = ["cascade", "set null", "set default", "restrict", "no action"] as const;
 

app/src/data/server/data-query-impl.ts

@@ -1,14 +1,8 @@
 import type { TThis } from "@sinclair/typebox";
-import {
-   type SchemaOptions,
-   type Static,
-   type StaticDecode,
-   StringEnum,
-   Type,
-   Value,
-   isObject,
-} from "core/utils";
+import { type SchemaOptions, type StaticDecode, StringEnum, Value, isObject } from "core/utils";
 import { WhereBuilder, type WhereQuery } from "../entities";
+import * as tbbox from "@sinclair/typebox";
+const { Type } = tbbox;
 
 const NumberOrString = (options: SchemaOptions = {}) =>
    Type.Transform(Type.Union([Type.Number(), Type.String()], options))

app/src/flows/flows-schema.ts

@@ -1,5 +1,7 @@
-import { Const, type Static, StringRecord, Type, transformObject } from "core/utils";
+import { Const, type Static, StringRecord, transformObject } from "core/utils";
 import { TaskMap, TriggerMap } from "flows";
+import * as tbbox from "@sinclair/typebox";
+const { Type } = tbbox;
 
 export const TASKS = {
    ...TaskMap,

app/src/flows/flows/triggers/EventTrigger.ts

@@ -1,7 +1,8 @@
 import type { EventManager } from "core/events";
-import { Type } from "core/utils";
 import type { Flow } from "../Flow";
 import { Trigger } from "./Trigger";
+import * as tbbox from "@sinclair/typebox";
+const { Type } = tbbox;
 
 export class EventTrigger extends Trigger<typeof EventTrigger.schema> {
    override type = "event";

app/src/flows/flows/triggers/HttpTrigger.ts

@@ -1,7 +1,9 @@
-import { StringEnum, Type } from "core/utils";
+import { StringEnum } from "core/utils";
 import type { Context, Hono } from "hono";
 import type { Flow } from "../Flow";
 import { Trigger } from "./Trigger";
+import * as tbbox from "@sinclair/typebox";
+const { Type } = tbbox;
 
 const httpMethods = ["GET", "POST", "PUT", "PATCH", "DELETE"] as const;
 

app/src/flows/flows/triggers/Trigger.ts

@@ -1,6 +1,8 @@
-import { type Static, StringEnum, Type, parse } from "core/utils";
+import { type Static, StringEnum, parse } from "core/utils";
 import type { Execution } from "../Execution";
 import type { Flow } from "../Flow";
+import * as tbbox from "@sinclair/typebox";
+const { Type } = tbbox;
 
 export class Trigger<Schema extends typeof Trigger.schema = typeof Trigger.schema> {
    // @todo: remove this

app/src/flows/tasks/Task.tsx

@@ -1,8 +1,9 @@
 import type { StaticDecode, TSchema } from "@sinclair/typebox";
-import type { NodeProps } from "@xyflow/react";
 import { BkndError, SimpleRenderer } from "core";
-import { type Static, type TObject, Type, Value, parse, ucFirst } from "core/utils";
-import type { ExecutionEvent, InputsMap } from "../flows/Execution";
+import { type Static, type TObject, Value, parse, ucFirst } from "core/utils";
+import type { InputsMap } from "../flows/Execution";
+import * as tbbox from "@sinclair/typebox";
+const { Type } = tbbox;
 //type InstanceOf<T> = T extends new (...args: any) => infer R ? R : never;
 
 export type TaskResult<Output = any> = {

app/src/flows/tasks/presets/FetchTask.ts

@@ -1,6 +1,7 @@
-import { StringEnum, Type } from "core/utils";
-import type { InputsMap } from "../../flows/Execution";
+import { StringEnum } from "core/utils";
 import { Task, dynamic } from "../Task";
+import * as tbbox from "@sinclair/typebox";
+const { Type } = tbbox;
 
 const FetchMethods = ["GET", "POST", "PUT", "PATCH", "DELETE"];
 

app/src/flows/tasks/presets/LogTask.ts

@@ -1,5 +1,6 @@
-import { Type } from "core/utils";
 import { Task } from "../Task";
+import * as tbbox from "@sinclair/typebox";
+const { Type } = tbbox;
 
 export class LogTask extends Task<typeof LogTask.schema> {
    type = "log";

app/src/flows/tasks/presets/RenderTask.ts

@@ -1,5 +1,6 @@
-import { Type } from "core/utils";
 import { Task } from "../Task";
+import * as tbbox from "@sinclair/typebox";
+const { Type } = tbbox;
 
 export class RenderTask<Output extends Record<string, any>> extends Task<
    typeof RenderTask.schema,

app/src/flows/tasks/presets/SubFlowTask.ts

@@ -1,6 +1,7 @@
-import { Type } from "core/utils";
 import { Flow } from "../../flows/Flow";
 import { Task, dynamic } from "../Task";
+import * as tbbox from "@sinclair/typebox";
+const { Type } = tbbox;
 
 export class SubFlowTask<Output extends Record<string, any>> extends Task<
    typeof SubFlowTask.schema,

app/src/media/MediaField.ts

@@ -1,5 +1,7 @@
-import { type Static, Type } from "core/utils";
+import type { Static } from "core/utils";
 import { Field, baseFieldConfigSchema } from "data";
+import * as tbbox from "@sinclair/typebox";
+const { Type } = tbbox;
 
 export const mediaFieldConfigSchema = Type.Composite([
    Type.Object({

app/src/media/api/MediaController.ts

@@ -1,10 +1,12 @@
 import { isDebug, tbValidator as tb } from "core";
-import { HttpStatus, Type, getFileFromContext, headersToObject } from "core/utils";
+import { HttpStatus, getFileFromContext } from "core/utils";
 import type { StorageAdapter } from "media";
 import { StorageEvents, getRandomizedFilename } from "media";
 import { Controller } from "modules/Controller";
 import type { AppMedia } from "../AppMedia";
 import { MediaField } from "../MediaField";
+import * as tbbox from "@sinclair/typebox";
+const { Type } = tbbox;
 
 const booleanLike = Type.Transform(Type.String())
    .Decode((v) => v === "1")

app/src/media/media-schema.ts

@@ -1,6 +1,8 @@
-import { Const, type Static, Type, objectTransform } from "core/utils";
+import { Const, type Static, objectTransform } from "core/utils";
 import { Adapters } from "media";
 import { registries } from "modules/registries";
+import * as tbbox from "@sinclair/typebox";
+const { Type } = tbbox;
 
 export const ADAPTERS = {
    ...Adapters,

app/src/media/storage/adapters/cloudinary/StorageCloudinaryAdapter.ts

@@ -1,7 +1,9 @@
 import { hash, pickHeaders } from "core/utils";
-import { type Static, Type, parse } from "core/utils";
+import { type Static, parse } from "core/utils";
 import type { FileBody, FileListObject, FileMeta } from "../../Storage";
 import { StorageAdapter } from "../../StorageAdapter";
+import * as tbbox from "@sinclair/typebox";
+const { Type } = tbbox;
 
 export const cloudinaryAdapterConfig = Type.Object(
    {

app/src/media/storage/adapters/s3/StorageS3Adapter.ts

@@ -7,10 +7,12 @@ import type {
    PutObjectRequest,
 } from "@aws-sdk/client-s3";
 import { AwsClient, isDebug } from "core";
-import { type Static, Type, isFile, parse, pickHeaders2 } from "core/utils";
+import { type Static, isFile, parse, pickHeaders2 } from "core/utils";
 import { transform } from "lodash-es";
 import type { FileBody, FileListObject } from "../../Storage";
 import { StorageAdapter } from "../../StorageAdapter";
+import * as tbbox from "@sinclair/typebox";
+const { Type } = tbbox;
 
 export const s3AdapterConfig = Type.Object(
    {

app/src/modules/ModuleManager.ts

@@ -6,7 +6,6 @@ import {
    Default,
    type Static,
    StringEnum,
-   Type,
    mark,
    objectEach,
    stripMark,
@@ -34,6 +33,8 @@ import { AppFlows } from "../flows/AppFlows";
 import { AppMedia } from "../media/AppMedia";
 import type { ServerEnv } from "./Controller";
 import { Module, type ModuleBuildContext } from "./Module";
+import * as tbbox from "@sinclair/typebox";
+const { Type } = tbbox;
 
 export type { ModuleBuildContext };
 

app/src/modules/server/AppServer.ts

@@ -1,7 +1,9 @@
 import { Exception, isDebug } from "core";
-import { type Static, StringEnum, Type } from "core/utils";
+import { type Static, StringEnum } from "core/utils";
 import { cors } from "hono/cors";
 import { Module } from "modules/Module";
+import * as tbbox from "@sinclair/typebox";
+const { Type } = tbbox;
 
 const serverMethods = ["GET", "POST", "PATCH", "PUT", "DELETE"];
 

app/src/modules/server/SystemController.ts

@@ -4,7 +4,6 @@ import type { App } from "App";
 import { $console, tbValidator as tb } from "core";
 import {
    StringEnum,
-   Type,
    TypeInvalidError,
    datetimeStringLocal,
    datetimeStringUTC,
@@ -14,6 +13,8 @@ import {
 import { getRuntimeKey } from "core/utils";
 import type { Context, Hono } from "hono";
 import { Controller } from "modules/Controller";
+import * as tbbox from "@sinclair/typebox";
+const { Type } = tbbox;
 
 import {
    MODULE_NAMES,

app/src/modules/server/openapi.ts

@@ -1,6 +1,7 @@
-import { Type } from "core/utils";
 import type { ModuleConfigs } from "modules/ModuleManager";
 import type { OpenAPIV3 as OAS } from "openapi-types";
+import * as tbbox from "@sinclair/typebox";
+const { Type } = tbbox;
 
 function prefixPaths(paths: OAS.PathsObject, prefix: string): OAS.PathsObject {
    const result: OAS.PathsObject = {};

app/src/ui/client/schema/data/use-bknd-data.ts

@@ -1,4 +1,4 @@
-import { Type, TypeInvalidError, parse, transformObject } from "core/utils";
+import { TypeInvalidError, parse, transformObject } from "core/utils";
 import { constructEntity } from "data";
 import {
    type TAppDataEntity,
@@ -13,6 +13,8 @@ import {
 import { useBknd } from "ui/client/bknd";
 import type { TSchemaActions } from "ui/client/schema/actions";
 import { bkndModals } from "ui/modals";
+import * as tb from "@sinclair/typebox";
+const { Type } = tb;
 
 export function useBkndData() {
    const { config, app, schema, actions: bkndActions } = useBknd();

app/src/ui/elements/auth/AuthForm.tsx

@@ -1,6 +1,5 @@
 import type { AppAuthOAuthStrategy, AppAuthSchema } from "auth/auth-schema";
 import clsx from "clsx";
-import { Type } from "core/utils";
 import { Form } from "json-schema-form-react";
 import { transform } from "lodash-es";
 import type { ComponentPropsWithoutRef } from "react";
@@ -11,6 +10,8 @@ import type { ValueError } from "@sinclair/typebox/value";
 import { type TSchema, Value } from "core/utils";
 import type { Validator } from "json-schema-form-react";
 import { useTheme } from "ui/client/use-theme";
+import * as tbbox from "@sinclair/typebox";
+const { Type } = tbbox;
 
 class TypeboxValidator implements Validator<ValueError> {
    async validate(schema: TSchema, data: any) {

app/src/ui/hooks/use-search.ts

@@ -2,7 +2,6 @@ import {
    type Static,
    type StaticDecode,
    type TSchema,
-   Type,
    decodeSearch,
    encodeSearch,
    parseDecode,

app/src/ui/modules/data/components/schema/create-modal/CreateModal.tsx

@@ -1,6 +1,6 @@
 import type { ModalProps } from "@mantine/core";
 import type { ContextModalProps } from "@mantine/modals";
-import { type Static, StringEnum, StringIdentifier, Type } from "core/utils";
+import { type Static, StringEnum, StringIdentifier } from "core/utils";
 import { entitiesSchema, fieldsSchema, relationsSchema } from "data/data-schema";
 import { useState } from "react";
 import { type Modal2Ref, ModalBody, ModalFooter, ModalTitle } from "ui/components/modal/Modal2";
@@ -11,6 +11,8 @@ import { StepEntityFields } from "./step.entity.fields";
 import { StepRelation } from "./step.relation";
 import { StepSelect } from "./step.select";
 import Templates from "./templates/register";
+import * as tbbox from "@sinclair/typebox";
+const { Type } = tbbox;
 
 export type CreateModalRef = Modal2Ref;
 

app/src/ui/modules/data/components/schema/create-modal/step.relation.tsx

@@ -2,15 +2,9 @@ import { typeboxResolver } from "@hookform/resolvers/typebox";
 import { Switch, TextInput } from "@mantine/core";
 import { TypeRegistry } from "@sinclair/typebox";
 import { IconDatabase } from "@tabler/icons-react";
-import {
-   type Static,
-   StringEnum,
-   StringIdentifier,
-   Type,
-   registerCustomTypeboxKinds,
-} from "core/utils";
+import { type Static, StringEnum, StringIdentifier, registerCustomTypeboxKinds } from "core/utils";
 import { ManyToOneRelation, type RelationType, RelationTypes } from "data";
-import { type ReactNode, startTransition, useEffect } from "react";
+import type { ReactNode } from "react";
 import { type Control, type FieldValues, type UseFormRegister, useForm } from "react-hook-form";
 import { TbRefresh } from "react-icons/tb";
 import { useBknd } from "ui/client/bknd";
@@ -20,6 +14,8 @@ import { MantineSelect } from "ui/components/form/hook-form-mantine/MantineSelec
 import { useStepContext } from "ui/components/steps/Steps";
 import { useEvent } from "ui/hooks/use-event";
 import { ModalBody, ModalFooter, type TCreateModalSchema } from "./CreateModal";
+import * as tbbox from "@sinclair/typebox";
+const { Type } = tbbox;
 
 // @todo: check if this could become an issue
 registerCustomTypeboxKinds(TypeRegistry);

app/src/ui/modules/data/components/schema/create-modal/templates/media/template.media.component.tsx

@@ -1,13 +1,6 @@
 import { typeboxResolver } from "@hookform/resolvers/typebox";
 import { Radio, TextInput } from "@mantine/core";
-import {
-   Default,
-   type Static,
-   StringEnum,
-   StringIdentifier,
-   Type,
-   transformObject,
-} from "core/utils";
+import { Default, type Static, StringEnum, StringIdentifier, transformObject } from "core/utils";
 import type { MediaFieldConfig } from "media/MediaField";
 import { useEffect, useState } from "react";
 import { useForm } from "react-hook-form";
@@ -22,6 +15,8 @@ import {
    type TFieldCreate,
    useStepContext,
 } from "../../CreateModal";
+import * as tbbox from "@sinclair/typebox";
+const { Type } = tbbox;
 
 const schema = Type.Object({
    entity: StringIdentifier,

app/src/ui/modules/flows/components/TriggerComponent.tsx

@@ -1,9 +1,11 @@
 import { Handle, type Node, type NodeProps, Position } from "@xyflow/react";
-import { Const, Type, transformObject } from "core/utils";
+import { Const, transformObject } from "core/utils";
 import { type Trigger, TriggerMap } from "flows";
 import type { IconType } from "react-icons";
 import { TbCircleLetterT } from "react-icons/tb";
 import { JsonSchemaForm } from "ui/components/form/json-schema";
+import * as tbbox from "@sinclair/typebox";
+const { Type } = tbbox;
 
 export type TaskComponentProps = NodeProps<Node<{ trigger: Trigger }>> & {
    Icon?: IconType;

app/src/ui/modules/flows/components2/nodes/tasks/FetchTaskNode.tsx

@@ -4,7 +4,6 @@ import { useToggle } from "@mantine/hooks";
 import { IconMinus, IconPlus, IconWorld } from "@tabler/icons-react";
 import type { Node, NodeProps } from "@xyflow/react";
 import type { Static } from "core/utils";
-import { Type } from "core/utils";
 import { FetchTask } from "flows";
 import { useRef, useState } from "react";
 import { useForm } from "react-hook-form";
@@ -15,6 +14,8 @@ import { MantineSelect } from "ui/components/form/hook-form-mantine/MantineSelec
 import { type TFlowNodeData, useFlowSelector } from "../../../hooks/use-flow";
 import { KeyValueInput } from "../../form/KeyValueInput";
 import { BaseNode } from "../BaseNode";
+import * as tbbox from "@sinclair/typebox";
+const { Type } = tbbox;
 
 const schema = Type.Composite([
    FetchTask.schema,

app/src/ui/modules/flows/components2/nodes/triggers/TriggerNode.tsx

@@ -1,20 +1,9 @@
 import { typeboxResolver } from "@hookform/resolvers/typebox";
 import { TextInput } from "@mantine/core";
-import { TypeRegistry } from "@sinclair/typebox";
-import { Clean } from "@sinclair/typebox/value";
-import { type Node, type NodeProps, Position } from "@xyflow/react";
-import {
-   Const,
-   type Static,
-   StringEnum,
-   Type,
-   registerCustomTypeboxKinds,
-   transformObject,
-} from "core/utils";
+import type { Node, NodeProps } from "@xyflow/react";
+import { Const, type Static, registerCustomTypeboxKinds, transformObject } from "core/utils";
 import { TriggerMap } from "flows";
 import type { TAppFlowTriggerSchema } from "flows/AppFlows";
-import { isEqual } from "lodash-es";
-import { useEffect } from "react";
 import { useForm } from "react-hook-form";
 import { JsonViewer } from "ui/components/code/JsonViewer";
 import { MantineSegmentedControl } from "ui/components/form/hook-form-mantine/MantineSegmentedControl";
@@ -22,6 +11,8 @@ import { MantineSelect } from "ui/components/form/hook-form-mantine/MantineSelec
 import { useFlowCanvas, useFlowSelector } from "../../../hooks/use-flow";
 import { BaseNode } from "../BaseNode";
 import { Handle } from "../Handle";
+import * as tb from "@sinclair/typebox";
+const { Type, TypeRegistry } = tb;
 
 // @todo: check if this could become an issue
 registerCustomTypeboxKinds(TypeRegistry);

app/src/ui/routes/auth/auth.settings.tsx

@@ -1,6 +1,6 @@
 import clsx from "clsx";
 import { isDebug } from "core";
-import { TbAlertCircle, TbChevronDown, TbChevronUp } from "react-icons/tb";
+import { TbChevronDown, TbChevronUp } from "react-icons/tb";
 import { useBknd } from "ui/client/BkndProvider";
 import { useBkndAuth } from "ui/client/schema/auth/use-bknd-auth";
 import { Button } from "ui/components/buttons/Button";

app/src/ui/routes/data/data.$entity.create.tsx

@@ -1,4 +1,3 @@
-import { Type } from "core/utils";
 import type { EntityData } from "data";
 import { useState } from "react";
 import { useEntityMutate } from "ui/client";
@@ -12,6 +11,8 @@ import { Breadcrumbs2 } from "ui/layouts/AppShell/Breadcrumbs2";
 import { routes } from "ui/lib/routes";
 import { EntityForm } from "ui/modules/data/components/EntityForm";
 import { useEntityForm } from "ui/modules/data/hooks/useEntityForm";
+import * as tbbox from "@sinclair/typebox";
+const { Type } = tbbox;
 
 export function DataEntityCreate({ params }) {
    const { $data } = useBkndData();

app/src/ui/routes/data/data.$entity.index.tsx

@@ -1,4 +1,3 @@
-import { Type } from "core/utils";
 import { type Entity, querySchema } from "data";
 import { Fragment } from "react";
 import { TbDots } from "react-icons/tb";
@@ -15,6 +14,8 @@ import * as AppShell from "ui/layouts/AppShell/AppShell";
 import { routes, useNavigate } from "ui/lib/routes";
 import { useCreateUserModal } from "ui/modules/auth/hooks/use-create-user-modal";
 import { EntityTable2 } from "ui/modules/data/components/EntityTable2";
+import * as tbbox from "@sinclair/typebox";
+const { Type } = tbbox;
 
 // @todo: migrate to Typebox
 const searchSchema = Type.Composite(

app/src/ui/routes/data/forms/entity.fields.form.tsx

@@ -5,7 +5,6 @@ import {
    Default,
    type Static,
    StringIdentifier,
-   Type,
    objectCleanEmpty,
    ucFirstAllSnakeToPascalWithSpaces,
 } from "core/utils";
@@ -27,6 +26,8 @@ import { type SortableItemProps, SortableList } from "ui/components/list/Sortabl
 import { Popover } from "ui/components/overlay/Popover";
 import { type TFieldSpec, fieldSpecs } from "ui/modules/data/components/fields-specs";
 import { dataFieldsUiSchema } from "../../settings/routes/data.settings";
+import * as tbbox from "@sinclair/typebox";
+const { Type } = tbbox;
 
 const fieldsSchemaObject = originalFieldsSchemaObject;
 const fieldsSchema = Type.Union(Object.values(fieldsSchemaObject));

app/src/ui/routes/flows/components/FlowCreateModal.tsx

@@ -2,13 +2,7 @@ import { typeboxResolver } from "@hookform/resolvers/typebox";
 import { TextInput } from "@mantine/core";
 import { useFocusTrap } from "@mantine/hooks";
 import { TypeRegistry } from "@sinclair/typebox";
-import {
-   type Static,
-   StringEnum,
-   StringIdentifier,
-   Type,
-   registerCustomTypeboxKinds,
-} from "core/utils";
+import { type Static, StringEnum, StringIdentifier, registerCustomTypeboxKinds } from "core/utils";
 import { TRIGGERS } from "flows/flows-schema";
 import { forwardRef, useState } from "react";
 import { useForm } from "react-hook-form";
@@ -22,6 +16,8 @@ import {
    ModalTitle,
 } from "../../../components/modal/Modal2";
 import { Step, Steps, useStepContext } from "../../../components/steps/Steps";
+import * as tbbox from "@sinclair/typebox";
+const { Type } = tbbox;
 
 registerCustomTypeboxKinds(TypeRegistry);