changed tb imports

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))