initial refactor

app/src/data/fields/BooleanField.ts

@@ -1,18 +1,17 @@
-import type { Static } from "core/utils";
+import { omitKeys } 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;
+import { s } from "core/object/schema";
 
-export const booleanFieldConfigSchema = Type.Composite([
-   Type.Object({
-      default_value: Type.Optional(Type.Boolean({ default: false })),
-   }),
-   baseFieldConfigSchema,
-]);
+export const booleanFieldConfigSchema = s
+   .strictObject({
+      default_value: s.boolean({ default: false }),
+      ...omitKeys(baseFieldConfigSchema.properties, ["default_value"]),
+   })
+   .partial();
 
-export type BooleanFieldConfig = Static<typeof booleanFieldConfigSchema>;
+export type BooleanFieldConfig = s.Static<typeof booleanFieldConfigSchema>;
 
 export class BooleanField<Required extends true | false = false> extends Field<
    BooleanFieldConfig,
@@ -86,7 +85,7 @@ export class BooleanField<Required extends true | false = false> extends Field<
    }
 
    override toJsonSchema() {
-      return this.toSchemaWrapIfRequired(Type.Boolean({ default: this.getDefault() }));
+      return this.toSchemaWrapIfRequired(s.boolean({ default: this.getDefault() }));
    }
 
    override toType() {

app/src/data/fields/DateField.ts

@@ -1,27 +1,21 @@
-import { type Static, StringEnum, dayjs } from "core/utils";
+import { dayjs, omitKeys } from "core/utils";
 import type { EntityManager } from "../entities";
 import { Field, type TActionContext, type TRenderContext, baseFieldConfigSchema } from "./Field";
 import { $console } from "core";
-import * as tbbox from "@sinclair/typebox";
 import type { TFieldTSType } from "data/entities/EntityTypescript";
-const { Type } = tbbox;
+import { s } from "core/object/schema";
 
-export const dateFieldConfigSchema = Type.Composite(
-   [
-      Type.Object({
-         type: StringEnum(["date", "datetime", "week"] as const, { default: "date" }),
-         timezone: Type.Optional(Type.String()),
-         min_date: Type.Optional(Type.String()),
-         max_date: Type.Optional(Type.String()),
-      }),
-      baseFieldConfigSchema,
-   ],
-   {
-      additionalProperties: false,
-   },
-);
+export const dateFieldConfigSchema = s
+   .strictObject({
+      type: s.string({ enum: ["date", "datetime", "week"], default: "date" }),
+      timezone: s.string(),
+      min_date: s.string(),
+      max_date: s.string(),
+      ...omitKeys(baseFieldConfigSchema.properties, ["default_value"]),
+   })
+   .partial();
 
-export type DateFieldConfig = Static<typeof dateFieldConfigSchema>;
+export type DateFieldConfig = s.Static<typeof dateFieldConfigSchema>;
 
 export class DateField<Required extends true | false = false> extends Field<
    DateFieldConfig,
@@ -143,7 +137,7 @@ export class DateField<Required extends true | false = false> extends Field<
 
    // @todo: check this
    override toJsonSchema() {
-      return this.toSchemaWrapIfRequired(Type.String({ default: this.getDefault() }));
+      return this.toSchemaWrapIfRequired(s.string({ default: this.getDefault() }));
    }
 
    override toType(): TFieldTSType {

app/src/data/fields/EnumField.ts

@@ -1,50 +1,33 @@
-import { Const, type Static, StringEnum } from "core/utils";
+import { omitKeys } from "core/utils";
 import type { EntityManager } from "data";
 import { TransformPersistFailedException } from "../errors";
 import { baseFieldConfigSchema, Field, type TActionContext, type TRenderContext } from "./Field";
-import * as tbbox from "@sinclair/typebox";
 import type { TFieldTSType } from "data/entities/EntityTypescript";
-const { Type } = tbbox;
+import { s } from "core/object/schema";
 
-export const enumFieldConfigSchema = Type.Composite(
-   [
-      Type.Object({
-         default_value: Type.Optional(Type.String()),
-         options: Type.Optional(
-            Type.Union([
-               Type.Object(
-                  {
-                     type: Const("strings"),
-                     values: Type.Array(Type.String()),
-                  },
-                  { title: "Strings" },
-               ),
-               Type.Object(
-                  {
-                     type: Const("objects"),
-                     values: Type.Array(
-                        Type.Object({
-                           label: Type.String(),
-                           value: Type.String(),
-                        }),
-                     ),
-                  },
-                  {
-                     title: "Objects",
-                     additionalProperties: false,
-                  },
-               ),
-            ]),
-         ),
-      }),
-      baseFieldConfigSchema,
-   ],
-   {
-      additionalProperties: false,
-   },
-);
+export const enumFieldConfigSchema = s
+   .strictObject({
+      default_value: s.string(),
+      options: s.anyOf([
+         s.object({
+            type: s.literal("strings"),
+            values: s.array(s.string()),
+         }),
+         s.object({
+            type: s.literal("objects"),
+            values: s.array(
+               s.object({
+                  label: s.string(),
+                  value: s.string(),
+               }),
+            ),
+         }),
+      ]),
+      ...omitKeys(baseFieldConfigSchema.properties, ["default_value"]),
+   })
+   .partial();
 
-export type EnumFieldConfig = Static<typeof enumFieldConfigSchema>;
+export type EnumFieldConfig = s.Static<typeof enumFieldConfigSchema>;
 
 export class EnumField<Required extends true | false = false, TypeOverride = string> extends Field<
    EnumFieldConfig,
@@ -136,7 +119,8 @@ export class EnumField<Required extends true | false = false, TypeOverride = str
          options.values?.map((option) => (typeof option === "string" ? option : option.value)) ??
          [];
       return this.toSchemaWrapIfRequired(
-         StringEnum(values, {
+         s.string({
+            enum: values,
             default: this.getDefault(),
          }),
       );

app/src/data/fields/Field.ts

@@ -1,18 +1,10 @@
-import {
-   parse,
-   snakeToPascalWithSpaces,
-   type Static,
-   StringEnum,
-   type TSchema,
-   TypeInvalidError,
-} from "core/utils";
+import { snakeToPascalWithSpaces } 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";
 import type { TFieldTSType } from "data/entities/EntityTypescript";
-const { Type } = tbbox;
+import { s, parse, InvalidSchemaError } from "core/object/schema";
 
 // @todo: contexts need to be reworked
 // e.g. "table" is irrelevant, because if read is not given, it fails
@@ -31,43 +23,36 @@ const DEFAULT_FILLABLE = true;
 const DEFAULT_HIDDEN = false;
 
 // @todo: add refine functions (e.g. if required, but not fillable, needs default value)
-export const baseFieldConfigSchema = Type.Object(
-   {
-      label: Type.Optional(Type.String()),
-      description: Type.Optional(Type.String()),
-      required: Type.Optional(Type.Boolean({ default: DEFAULT_REQUIRED })),
-      fillable: Type.Optional(
-         Type.Union(
-            [
-               Type.Boolean({ title: "Boolean", default: DEFAULT_FILLABLE }),
-               Type.Array(StringEnum(ActionContext), { title: "Context", uniqueItems: true }),
-            ],
-            {
-               default: DEFAULT_FILLABLE,
-            },
-         ),
+export const baseFieldConfigSchema = s
+   .strictObject({
+      label: s.string(),
+      description: s.string(),
+      required: s.boolean({ default: DEFAULT_REQUIRED }),
+      fillable: s.anyOf(
+         [
+            s.boolean({ title: "Boolean", default: DEFAULT_FILLABLE }),
+            s.array(s.string({ enum: ActionContext }), { title: "Context", uniqueItems: true }),
+         ],
+         {
+            default: DEFAULT_FILLABLE,
+         },
       ),
-      hidden: Type.Optional(
-         Type.Union(
-            [
-               Type.Boolean({ title: "Boolean", default: DEFAULT_HIDDEN }),
-               // @todo: tmp workaround
-               Type.Array(StringEnum(TmpContext), { title: "Context", uniqueItems: true }),
-            ],
-            {
-               default: DEFAULT_HIDDEN,
-            },
-         ),
+      hidden: s.anyOf(
+         [
+            s.boolean({ title: "Boolean", default: DEFAULT_HIDDEN }),
+            // @todo: tmp workaround
+            s.array(s.string({ enum: TmpContext }), { title: "Context", uniqueItems: true }),
+         ],
+         {
+            default: DEFAULT_HIDDEN,
+         },
       ),
       // if field is virtual, it will not call transformPersist & transformRetrieve
-      virtual: Type.Optional(Type.Boolean()),
-      default_value: Type.Optional(Type.Any()),
-   },
-   {
-      additionalProperties: false,
-   },
-);
-export type BaseFieldConfig = Static<typeof baseFieldConfigSchema>;
+      virtual: s.boolean(),
+      default_value: s.any(),
+   })
+   .partial();
+export type BaseFieldConfig = s.Static<typeof baseFieldConfigSchema>;
 
 export abstract class Field<
    Config extends BaseFieldConfig = BaseFieldConfig,
@@ -92,7 +77,7 @@ export abstract class Field<
       try {
          this.config = parse(this.getSchema(), config || {}) as Config;
       } catch (e) {
-         if (e instanceof TypeInvalidError) {
+         if (e instanceof InvalidSchemaError) {
             throw new InvalidFieldConfigException(this, config, e);
          }
 
@@ -104,7 +89,7 @@ export abstract class Field<
       return this.type;
    }
 
-   protected abstract getSchema(): TSchema;
+   protected abstract getSchema(): s.ObjectSchema;
 
    /**
     * Used in SchemaManager.ts
@@ -224,16 +209,16 @@ export abstract class Field<
       return value;
    }
 
-   protected toSchemaWrapIfRequired<Schema extends TSchema>(schema: Schema) {
-      return this.isRequired() ? schema : Type.Optional(schema);
+   protected toSchemaWrapIfRequired<Schema extends s.Schema>(schema: Schema): Schema {
+      return this.isRequired() ? schema : (schema.optional() as any);
    }
 
    protected nullish(value: any) {
       return value === null || value === undefined;
    }
 
-   toJsonSchema(): TSchema {
-      return this.toSchemaWrapIfRequired(Type.Any());
+   toJsonSchema(): s.Schema {
+      return this.toSchemaWrapIfRequired(s.any());
    }
 
    toType(): TFieldTSType {

app/src/data/fields/JsonField.ts

@@ -1,14 +1,18 @@
-import type { Static } from "core/utils";
+import { omitKeys } 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";
 import type { TFieldTSType } from "data/entities/EntityTypescript";
-const { Type } = tbbox;
+import { s } from "core/object/schema";
 
-export const jsonFieldConfigSchema = Type.Composite([baseFieldConfigSchema, Type.Object({})]);
+export const jsonFieldConfigSchema = s
+   .strictObject({
+      default_value: s.any(),
+      ...omitKeys(baseFieldConfigSchema.properties, ["default_value"]),
+   })
+   .partial();
 
-export type JsonFieldConfig = Static<typeof jsonFieldConfigSchema>;
+export type JsonFieldConfig = s.Static<typeof jsonFieldConfigSchema>;
 
 export class JsonField<Required extends true | false = false, TypeOverride = object> extends Field<
    JsonFieldConfig,

app/src/data/fields/JsonSchemaField.ts

@@ -1,27 +1,21 @@
 import { type Schema as JsonSchema, Validator } from "@cfworker/json-schema";
-import { Default, FromSchema, objectToJsLiteral, type Static } from "core/utils";
+import { FromSchema, objectToJsLiteral, omitKeys } 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";
 import type { TFieldTSType } from "data/entities/EntityTypescript";
-const { Type } = tbbox;
+import { s } from "core/object/schema";
 
-export const jsonSchemaFieldConfigSchema = Type.Composite(
-   [
-      Type.Object({
-         schema: Type.Object({}, { default: {} }),
-         ui_schema: Type.Optional(Type.Object({})),
-         default_from_schema: Type.Optional(Type.Boolean()),
-      }),
-      baseFieldConfigSchema,
-   ],
-   {
-      additionalProperties: false,
-   },
-);
+export const jsonSchemaFieldConfigSchema = s
+   .strictObject({
+      schema: s.any({ type: "object", default: {} }),
+      ui_schema: s.any({ type: "object", default: {} }),
+      default_from_schema: s.boolean(),
+      ...omitKeys(baseFieldConfigSchema.properties, ["default_value"]),
+   })
+   .partial();
 
-export type JsonSchemaFieldConfig = Static<typeof jsonSchemaFieldConfigSchema>;
+export type JsonSchemaFieldConfig = s.Static<typeof jsonSchemaFieldConfigSchema>;
 
 export class JsonSchemaField<
    Required extends true | false = false,
@@ -84,7 +78,7 @@ export class JsonSchemaField<
       if (val === null) {
          if (this.config.default_from_schema) {
             try {
-               return Default(FromSchema(this.getJsonSchema()), {});
+               return s.fromSchema(this.getJsonSchema()).template();
             } catch (e) {
                return null;
             }
@@ -116,7 +110,7 @@ export class JsonSchemaField<
    override toJsonSchema() {
       const schema = this.getJsonSchema() ?? { type: "object" };
       return this.toSchemaWrapIfRequired(
-         FromSchema({
+         s.fromSchema({
             default: this.getDefault(),
             ...schema,
          }),

app/src/data/fields/NumberField.ts

@@ -1,29 +1,23 @@
-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";
 import type { TFieldTSType } from "data/entities/EntityTypescript";
-const { Type } = tbbox;
+import { s } from "core/object/schema";
+import { omitKeys } from "core/utils";
 
-export const numberFieldConfigSchema = Type.Composite(
-   [
-      Type.Object({
-         default_value: Type.Optional(Type.Number()),
-         minimum: Type.Optional(Type.Number()),
-         maximum: Type.Optional(Type.Number()),
-         exclusiveMinimum: Type.Optional(Type.Number()),
-         exclusiveMaximum: Type.Optional(Type.Number()),
-         multipleOf: Type.Optional(Type.Number()),
-      }),
-      baseFieldConfigSchema,
-   ],
-   {
-      additionalProperties: false,
-   },
-);
+export const numberFieldConfigSchema = s
+   .strictObject({
+      default_value: s.number(),
+      minimum: s.number(),
+      maximum: s.number(),
+      exclusiveMinimum: s.number(),
+      exclusiveMaximum: s.number(),
+      multipleOf: s.number(),
+      ...omitKeys(baseFieldConfigSchema.properties, ["default_value"]),
+   })
+   .partial();
 
-export type NumberFieldConfig = Static<typeof numberFieldConfigSchema>;
+export type NumberFieldConfig = s.Static<typeof numberFieldConfigSchema>;
 
 export class NumberField<Required extends true | false = false> extends Field<
    NumberFieldConfig,
@@ -93,7 +87,7 @@ export class NumberField<Required extends true | false = false> extends Field<
 
    override toJsonSchema() {
       return this.toSchemaWrapIfRequired(
-         Type.Number({
+         s.number({
             default: this.getDefault(),
             minimum: this.config?.minimum,
             maximum: this.config?.maximum,

app/src/data/fields/PrimaryField.ts

@@ -1,22 +1,22 @@
 import { config } from "core";
-import { StringEnum, uuidv7, type Static } from "core/utils";
+import { omitKeys, uuidv7 } from "core/utils";
 import { Field, baseFieldConfigSchema } from "./Field";
-import * as tbbox from "@sinclair/typebox";
 import type { TFieldTSType } from "data/entities/EntityTypescript";
-const { Type } = tbbox;
+import { s } from "core/object/schema";
+import type { FieldSpec } from "data/connection/Connection";
 
 export const primaryFieldTypes = ["integer", "uuid"] as const;
 export type TPrimaryFieldFormat = (typeof primaryFieldTypes)[number];
 
-export const primaryFieldConfigSchema = Type.Composite([
-   Type.Omit(baseFieldConfigSchema, ["required"]),
-   Type.Object({
-      format: Type.Optional(StringEnum(primaryFieldTypes, { default: "integer" })),
-      required: Type.Optional(Type.Literal(false)),
-   }),
-]);
+export const primaryFieldConfigSchema = s
+   .strictObject({
+      format: s.string({ enum: primaryFieldTypes, default: "integer" }),
+      required: s.boolean({ default: false }),
+      ...omitKeys(baseFieldConfigSchema.properties, ["required"]),
+   })
+   .partial();
 
-export type PrimaryFieldConfig = Static<typeof primaryFieldConfigSchema>;
+export type PrimaryFieldConfig = s.Static<typeof primaryFieldConfigSchema>;
 
 export class PrimaryField<Required extends true | false = false> extends Field<
    PrimaryFieldConfig,
@@ -41,7 +41,7 @@ export class PrimaryField<Required extends true | false = false> extends Field<
       return this.config.format ?? "integer";
    }
 
-   get fieldType() {
+   get fieldType(): "integer" | "text" {
       return this.format === "integer" ? "integer" : "text";
    }
 
@@ -67,11 +67,11 @@ export class PrimaryField<Required extends true | false = false> extends Field<
    }
 
    override toJsonSchema() {
-      if (this.format === "uuid") {
-         return this.toSchemaWrapIfRequired(Type.String({ writeOnly: undefined }));
-      }
-
-      return this.toSchemaWrapIfRequired(Type.Number({ writeOnly: undefined }));
+      return this.toSchemaWrapIfRequired(
+         this.format === "integer"
+            ? s.number({ writeOnly: undefined })
+            : s.string({ writeOnly: undefined }),
+      );
    }
 
    override toType(): TFieldTSType {

app/src/data/fields/TextField.ts

@@ -1,42 +1,24 @@
 import type { EntityManager } from "data";
-import type { Static } from "core/utils";
+import { omitKeys } from "core/utils";
 import { TransformPersistFailedException } from "../errors";
 import { Field, type TActionContext, baseFieldConfigSchema } from "./Field";
-import * as tb from "@sinclair/typebox";
-const { Type } = tb;
+import { s } from "core/object/schema";
 
-export const textFieldConfigSchema = Type.Composite(
-   [
-      Type.Object({
-         default_value: Type.Optional(Type.String()),
-         minLength: Type.Optional(Type.Number()),
-         maxLength: Type.Optional(Type.Number()),
-         pattern: Type.Optional(Type.String()),
-         html_config: Type.Optional(
-            Type.Object({
-               element: Type.Optional(Type.String({ default: "input" })),
-               props: Type.Optional(
-                  Type.Object(
-                     {},
-                     {
-                        additionalProperties: Type.Union([
-                           Type.String({ title: "String" }),
-                           Type.Number({ title: "Number" }),
-                        ]),
-                     },
-                  ),
-               ),
-            }),
-         ),
+export const textFieldConfigSchema = s
+   .strictObject({
+      default_value: s.string(),
+      minLength: s.number(),
+      maxLength: s.number(),
+      pattern: s.string(),
+      html_config: s.object({
+         element: s.string({ default: "input" }),
+         props: s.record(s.anyOf([s.string({ title: "String" }), s.number({ title: "Number" })])),
       }),
-      baseFieldConfigSchema,
-   ],
-   {
-      additionalProperties: false,
-   },
-);
+      ...omitKeys(baseFieldConfigSchema.properties, ["default_value"]),
+   })
+   .partial();
 
-export type TextFieldConfig = Static<typeof textFieldConfigSchema>;
+export type TextFieldConfig = s.Static<typeof textFieldConfigSchema>;
 
 export class TextField<Required extends true | false = false> extends Field<
    TextFieldConfig,
@@ -113,7 +95,7 @@ export class TextField<Required extends true | false = false> extends Field<
 
    override toJsonSchema() {
       return this.toSchemaWrapIfRequired(
-         Type.String({
+         s.string({
             default: this.getDefault(),
             minLength: this.config?.minLength,
             maxLength: this.config?.maxLength,

app/src/data/fields/VirtualField.ts

@@ -1,11 +1,13 @@
-import type { Static } from "core/utils";
 import { Field, baseFieldConfigSchema } from "./Field";
-import * as tbbox from "@sinclair/typebox";
-const { Type } = tbbox;
+import { s } from "core/object/schema";
 
-export const virtualFieldConfigSchema = Type.Composite([baseFieldConfigSchema, Type.Object({})]);
+export const virtualFieldConfigSchema = s
+   .strictObject({
+      ...baseFieldConfigSchema.properties,
+   })
+   .partial();
 
-export type VirtualFieldConfig = Static<typeof virtualFieldConfigSchema>;
+export type VirtualFieldConfig = s.Static<typeof virtualFieldConfigSchema>;
 
 export class VirtualField extends Field<VirtualFieldConfig> {
    override readonly type = "virtual";
@@ -25,7 +27,7 @@ export class VirtualField extends Field<VirtualFieldConfig> {
 
    override toJsonSchema() {
       return this.toSchemaWrapIfRequired(
-         Type.Any({
+         s.any({
             default: this.getDefault(),
             readOnly: true,
          }),