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>
2026-03-16 20:37:21 +00:00 · 2025-08-01 15:55:59 +02:00
parent daaaae82b6
commit a298b65abf
430 changed files with 15041 additions and 12375 deletions
--- a/app/src/data/AppData.ts
+++ b/app/src/data/AppData.ts
@@ -1,17 +1,14 @@
 import { transformObject } from "core/utils";
-import {
-   DataPermissions,
-   type Entity,
-   EntityIndex,
-   type EntityManager,
-   constructEntity,
-   constructRelation,
-} from "data";
+
 import { Module } from "modules/Module";
 import { DataController } from "./api/DataController";
 import { type AppDataConfig, dataConfigSchema } from "./data-schema";
+import { constructEntity, constructRelation } from "./schema/constructor";
+import type { Entity, EntityManager } from "data/entities";
+import { EntityIndex } from "data/fields";
+import * as DataPermissions from "data/permissions";

-export class AppData extends Module<typeof dataConfigSchema> {
+export class AppData extends Module<AppDataConfig> {
   override async build() {
      const {
         entities: _entities = {},
--- a/app/src/data/api/DataApi.ts
+++ b/app/src/data/api/DataApi.ts
@@ -1,8 +1,9 @@
-import type { DB } from "core";
-import type { EntityData, RepoQueryIn, RepositoryResultJSON } from "data";
+import type { DB, EntityData, RepoQueryIn } from "bknd";
+
 import type { Insertable, Selectable, Updateable } from "kysely";
 import { type BaseModuleApiOptions, ModuleApi, type PrimaryFieldType } from "modules";
 import type { FetchPromise, ResponseObject } from "modules/ModuleApi";
+import type { RepositoryResultJSON } from "data/entities/query/RepositoryResult";

 export type DataApiOptions = BaseModuleApiOptions & {
   queryLengthLimit: number;
--- a/app/src/data/api/DataController.ts
+++ b/app/src/data/api/DataController.ts
@@ -1,17 +1,12 @@
-import {
-   DataPermissions,
-   type EntityData,
-   type EntityManager,
-   type RepoQuery,
-   repoQuery,
-} from "data";
 import type { Handler } from "hono/types";
 import type { ModuleBuildContext } from "modules";
 import { Controller } from "modules/Controller";
-import { jsc, s, describeRoute, schemaToSpec } from "core/object/schema";
+import { jsc, s, describeRoute, schemaToSpec, omitKeys } from "bknd/utils";
 import * as SystemPermissions from "modules/permissions";
 import type { AppDataConfig } from "../data-schema";
-import { omitKeys } from "core/utils";
+import type { EntityManager, EntityData } from "data/entities";
+import * as DataPermissions from "data/permissions";
+import { repoQuery, type RepoQuery } from "data/server/query";

 export class DataController extends Controller {
   constructor(
@@ -73,10 +68,12 @@ export class DataController extends Controller {
         }),
         jsc(
            "query",
-            s.partialObject({
-               force: s.boolean(),
-               drop: s.boolean(),
-            }),
+            s
+               .object({
+                  force: s.boolean(),
+                  drop: s.boolean(),
+               })
+               .partial(),
         ),
         async (c) => {
            const { force, drop } = c.req.valid("query");
@@ -204,7 +201,7 @@ export class DataController extends Controller {

      const entitiesEnum = this.getEntitiesEnum(this.em);
      // @todo: make dynamic based on entity
-      const idType = s.anyOf([s.number(), s.string()], { coerce: (v) => v as any });
+      const idType = s.anyOf([s.number(), s.string()], { coerce: (v) => v as number | string });

      /**
       * Function endpoints
@@ -257,12 +254,14 @@ export class DataController extends Controller {
       * Read endpoints
       */
      // read many
-      const saveRepoQuery = s.partialObject({
-         ...omitKeys(repoQuery.properties, ["with"]),
-         sort: s.string({ default: "id" }),
-         select: s.array(s.string()),
-         join: s.array(s.string()),
-      });
+      const saveRepoQuery = s
+         .object({
+            ...omitKeys(repoQuery.properties, ["with"]),
+            sort: s.string({ default: "id" }),
+            select: s.array(s.string()),
+            join: s.array(s.string()),
+         })
+         .partial();
      const saveRepoQueryParams = (pick: string[] = Object.keys(repoQuery.properties)) => [
         ...(schemaToSpec(saveRepoQuery, "query").parameters?.filter(
            // @ts-ignore
@@ -355,10 +354,12 @@ export class DataController extends Controller {
      );

      // func query
-      const fnQuery = s.partialObject({
-         ...saveRepoQuery.properties,
-         with: s.object({}),
-      });
+      const fnQuery = s
+         .object({
+            ...saveRepoQuery.properties,
+            with: s.object({}),
+         })
+         .partial();
      hono.post(
         "/:entity/query",
         describeRoute({
@@ -381,7 +382,7 @@ export class DataController extends Controller {
            if (!this.entityExists(entity)) {
               return this.notFound(c);
            }
-            const options = (await c.req.json()) as RepoQuery;
+            const options = c.req.valid("json") as RepoQuery;
            const result = await this.em.repository(entity).findMany(options);

            return c.json(result, { status: result.data ? 200 : 404 });
@@ -391,7 +392,7 @@ export class DataController extends Controller {
      /**
       * Mutation endpoints
       */
-      // insert one
+      // insert one or many
      hono.post(
         "/:entity",
         describeRoute({
--- a/app/src/data/connection/Connection.ts
+++ b/app/src/data/connection/Connection.ts
@@ -18,7 +18,8 @@ import {
   sql,
 } from "kysely";
 import type { BaseIntrospector, BaseIntrospectorConfig } from "./BaseIntrospector";
-import type { Constructor, DB } from "core";
+import type { DB } from "bknd";
+import type { Constructor } from "core/registry/Registry";
 import { KyselyPluginRunner } from "data/plugins/KyselyPluginRunner";
 import type { Field } from "data/fields/Field";

@@ -38,7 +39,7 @@ export interface SelectQueryBuilderExpression<O> extends AliasableExpression<O>

 export type SchemaResponse = [string, ColumnDataType, ColumnBuilderCallback] | undefined;

-const FieldSpecTypes = [
+export const FieldSpecTypes = [
   "text",
   "integer",
   "real",
--- a/app/src/data/connection/sqlite/SqliteConnection.ts
+++ b/app/src/data/connection/sqlite/SqliteConnection.ts
@@ -8,7 +8,7 @@ import {
 } from "kysely";
 import { jsonArrayFrom, jsonBuildObject, jsonObjectFrom } from "kysely/helpers/sqlite";
 import { Connection, type DbFunctions, type FieldSpec, type SchemaResponse } from "../Connection";
-import type { Constructor } from "core";
+import type { Constructor } from "core/registry/Registry";
 import { customIntrospector } from "../Connection";
 import { SqliteIntrospector } from "./SqliteIntrospector";
 import type { Field } from "data/fields/Field";
--- a/app/src/data/data-schema.ts
+++ b/app/src/data/data-schema.ts
@@ -1,10 +1,10 @@
-import { type Static, StringEnum, StringRecord, objectTransform } from "core/utils";
-import * as tb from "@sinclair/typebox";
+import { objectTransform } from "core/utils";
 import { MediaField, mediaFieldConfigSchema } from "../media/MediaField";
 import { FieldClassMap } from "data/fields";
 import { RelationClassMap, RelationFieldClassMap } from "data/relations";
 import { entityConfigSchema, entityTypes } from "data/entities";
 import { primaryFieldTypes } from "./fields";
+import { s } from "bknd/utils";

 export const FIELDS = {
   ...FieldClassMap,
@@ -16,69 +16,57 @@ export type FieldType = keyof typeof FIELDS;
 export const RELATIONS = RelationClassMap;

 export const fieldsSchemaObject = objectTransform(FIELDS, (field, name) => {
-   return tb.Type.Object(
+   return s.strictObject(
      {
-         type: tb.Type.Const(name, { default: name, readOnly: true }),
-         config: tb.Type.Optional(field.schema),
+         name: s.string().optional(), // @todo: verify, old schema wasn't strict (req in UI)
+         type: s.literal(name),
+         config: field.schema.optional(),
      },
      {
         title: name,
      },
   );
 });
-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 fieldsSchema = s.anyOf(Object.values(fieldsSchemaObject));
+export const entityFields = s.record(fieldsSchema);
+export type TAppDataField = s.Static<typeof fieldsSchema>;
+export type TAppDataEntityFields = s.Static<typeof entityFields>;

-export const entitiesSchema = tb.Type.Object({
-   type: tb.Type.Optional(
-      tb.Type.String({ enum: entityTypes, default: "regular", readOnly: true }),
-   ),
-   config: tb.Type.Optional(entityConfigSchema),
-   fields: tb.Type.Optional(entityFields),
+export const entitiesSchema = s.strictObject({
+   name: s.string().optional(), // @todo: verify, old schema wasn't strict (req in UI)
+   type: s.string({ enum: entityTypes, default: "regular" }),
+   config: entityConfigSchema,
+   fields: entityFields,
 });
-export type TAppDataEntity = Static<typeof entitiesSchema>;
+export type TAppDataEntity = s.Static<typeof entitiesSchema>;

 export const relationsSchema = Object.entries(RelationClassMap).map(([name, relationClass]) => {
-   return tb.Type.Object(
+   return s.strictObject(
      {
-         type: tb.Type.Const(name, { default: name, readOnly: true }),
-         source: tb.Type.String(),
-         target: tb.Type.String(),
-         config: tb.Type.Optional(relationClass.schema),
+         type: s.literal(name),
+         source: s.string(),
+         target: s.string(),
+         config: relationClass.schema.optional(),
      },
      {
         title: name,
      },
   );
 });
-export type TAppDataRelation = Static<(typeof relationsSchema)[number]>;
+export type TAppDataRelation = s.Static<(typeof relationsSchema)[number]>;

-export const indicesSchema = tb.Type.Object(
-   {
-      entity: tb.Type.String(),
-      fields: tb.Type.Array(tb.Type.String(), { minItems: 1 }),
-      unique: tb.Type.Optional(tb.Type.Boolean({ default: false })),
-   },
-   {
-      additionalProperties: false,
-   },
-);
+export const indicesSchema = s.strictObject({
+   entity: s.string(),
+   fields: s.array(s.string(), { minItems: 1 }),
+   unique: s.boolean({ default: false }).optional(),
+});

-export const dataConfigSchema = tb.Type.Object(
-   {
-      basepath: tb.Type.Optional(tb.Type.String({ default: "/api/data" })),
-      default_primary_format: tb.Type.Optional(
-         StringEnum(primaryFieldTypes, { default: "integer" }),
-      ),
-      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,
-   },
-);
+export const dataConfigSchema = s.strictObject({
+   basepath: s.string({ default: "/api/data" }).optional(),
+   default_primary_format: s.string({ enum: primaryFieldTypes, default: "integer" }).optional(),
+   entities: s.record(entitiesSchema, { default: {} }).optional(),
+   relations: s.record(s.anyOf(relationsSchema), { default: {} }).optional(),
+   indices: s.record(indicesSchema, { default: {} }).optional(),
+});

-export type AppDataConfig = Static<typeof dataConfigSchema>;
+export type AppDataConfig = s.Static<typeof dataConfigSchema>;
--- a/app/src/data/entities/Entity.ts
+++ b/app/src/data/entities/Entity.ts
@@ -1,12 +1,5 @@
-import { config } from "core";
-import {
-   $console,
-   type Static,
-   StringEnum,
-   parse,
-   snakeToPascalWithSpaces,
-   transformObject,
-} from "core/utils";
+import { config } from "core/config";
+import { snakeToPascalWithSpaces, transformObject, $console, s, parse } from "bknd/utils";
 import {
   type Field,
   PrimaryField,
@@ -14,25 +7,20 @@ import {
   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(
-   {
-      name: Type.Optional(Type.String()),
-      name_singular: Type.Optional(Type.String()),
-      description: Type.Optional(Type.String()),
-      sort_field: Type.Optional(Type.String({ default: config.data.default_primary_field })),
-      sort_dir: Type.Optional(StringEnum(["asc", "desc"], { default: "asc" })),
-      primary_format: Type.Optional(StringEnum(primaryFieldTypes)),
-   },
-   {
-      additionalProperties: false,
-   },
-);
+export const entityConfigSchema = s
+   .strictObject({
+      name: s.string(),
+      name_singular: s.string(),
+      description: s.string(),
+      sort_field: s.string({ default: config.data.default_primary_field }),
+      sort_dir: s.string({ enum: ["asc", "desc"], default: "asc" }),
+      primary_format: s.string({ enum: primaryFieldTypes }),
+   })
+   .partial();

-export type EntityConfig = Static<typeof entityConfigSchema>;
+export type EntityConfig = s.Static<typeof entityConfigSchema>;

 export type EntityData = Record<string, any>;
 export type EntityJSON = ReturnType<Entity["toJSON"]>;
@@ -288,8 +276,10 @@ export class Entity<
      }

      const _fields = Object.fromEntries(fields.map((field) => [field.name, field]));
-      const schema = Type.Object(
-         transformObject(_fields, (field) => {
+      const schema = {
+         type: "object",
+         additionalProperties: false,
+         properties: transformObject(_fields, (field) => {
            const fillable = field.isFillable(options?.context);
            return {
               title: field.config.label,
@@ -299,8 +289,7 @@ export class Entity<
               ...field.toJsonSchema(),
            };
         }),
-         { additionalProperties: false },
-      );
+      };

      return options?.clean ? JSON.parse(JSON.stringify(schema)) : schema;
   }
--- a/app/src/data/entities/EntityManager.ts
+++ b/app/src/data/entities/EntityManager.ts
@@ -1,5 +1,5 @@
-import type { DB as DefaultDB } from "core";
-import { $console } from "core/utils";
+import type { DB as DefaultDB } from "bknd";
+import { $console } from "bknd/utils";
 import { EventManager } from "core/events";
 import { sql } from "kysely";
 import { Connection } from "../connection/Connection";
@@ -67,6 +67,13 @@ export class EntityManager<TBD extends object = DefaultDB> {
      return new EntityManager(this._entities, this.connection, this._relations, this._indices);
   }

+   clear(): this {
+      this._entities = [];
+      this._relations = [];
+      this._indices = [];
+      return this;
+   }
+
   get entities(): Entity[] {
      return this._entities;
   }
--- a/app/src/data/entities/EntityTypescript.ts
+++ b/app/src/data/entities/EntityTypescript.ts
@@ -1,4 +1,5 @@
-import type { Entity, EntityManager, EntityRelation, TEntityType } from "data";
+import type { Entity, EntityManager, TEntityType } from "data/entities";
+import type { EntityRelation } from "data/relations";
 import { autoFormatString } from "core/utils";
 import { usersFields } from "auth/auth-entities";
 import { mediaFields } from "media/media-entities";
@@ -169,7 +170,7 @@ export class EntityTypescript {
      const strings: string[] = [];
      const tables: Record<string, string> = {};
      const imports: Record<string, string[]> = {
-         "bknd/core": ["DB"],
+         bknd: ["DB"],
         kysely: ["Insertable", "Selectable", "Updateable", "Generated"],
      };

@@ -206,7 +207,7 @@ export class EntityTypescript {
      strings.push(tables_string);

      // merge
-      let merge = `declare module "bknd/core" {\n`;
+      let merge = `declare module "bknd" {\n`;
      for (const systemEntity of system_entities) {
         const system_fields = Object.keys(systemEntities[systemEntity.name]);
         const additional_fields = systemEntity.fields
--- a/app/src/data/entities/Result.ts
+++ b/app/src/data/entities/Result.ts
@@ -1,4 +1,4 @@
-import { isDebug } from "core";
+import { isDebug } from "core/env";
 import { pick } from "core/utils";
 import type { Connection } from "data/connection";
 import type {
--- a/app/src/data/entities/mutation/Mutator.ts
+++ b/app/src/data/entities/mutation/Mutator.ts
@@ -1,7 +1,7 @@
-import type { DB as DefaultDB, PrimaryFieldType } from "core";
+import type { DB as DefaultDB, PrimaryFieldType } from "bknd";
 import { type EmitsEvents, EventManager } from "core/events";
 import type { DeleteQueryBuilder, InsertQueryBuilder, UpdateQueryBuilder } from "kysely";
-import type { TActionContext } from "../..";
+import type { TActionContext } from "data/fields";
 import { WhereBuilder } from "../query/WhereBuilder";
 import type { Entity, EntityData, EntityManager } from "../../entities";
 import { InvalidSearchParamsException } from "../../errors";
@@ -9,7 +9,6 @@ import { MutatorEvents } from "../../events";
 import { RelationMutator } from "../../relations";
 import type { RepoQuery } from "../../server/query";
 import { MutatorResult, type MutatorResultOptions } from "./MutatorResult";
-import { transformObject } from "core/utils";

 type MutatorQB =
   | InsertQueryBuilder<any, any, any>
--- a/app/src/data/entities/mutation/MutatorResult.ts
+++ b/app/src/data/entities/mutation/MutatorResult.ts
@@ -2,7 +2,7 @@ import { $console } from "core/utils";
 import type { Entity, EntityData } from "../Entity";
 import type { EntityManager } from "../EntityManager";
 import { Result, type ResultJSON, type ResultOptions } from "../Result";
-import { isDebug } from "core";
+import { isDebug } from "core/env";

 export type MutatorResultOptions = ResultOptions & {
   silent?: boolean;
--- a/app/src/data/entities/query/Repository.ts
+++ b/app/src/data/entities/query/Repository.ts
@@ -1,4 +1,4 @@
-import type { DB as DefaultDB, PrimaryFieldType } from "core";
+import type { DB as DefaultDB, PrimaryFieldType } from "bknd";
 import { $console } from "core/utils";
 import { type EmitsEvents, EventManager } from "core/events";
 import { type SelectQueryBuilder, sql } from "kysely";
@@ -14,7 +14,6 @@ import {
 } from "../index";
 import { JoinBuilder } from "./JoinBuilder";
 import { RepositoryResult, type RepositoryResultOptions } from "./RepositoryResult";
-import type { ResultOptions } from "../Result";

 export type RepositoryQB = SelectQueryBuilder<any, any, any>;

@@ -78,8 +77,8 @@ export class Repository<TBD extends object = DefaultDB, TB extends keyof TBD = a

         this.checkIndex(entity.name, options.sort.by, "sort");
         validated.sort = {
-            dir: "asc",
-            ...options.sort,
+            dir: options.sort.dir ?? "asc",
+            by: options.sort.by,
         };
      }

@@ -120,7 +119,7 @@ export class Repository<TBD extends object = DefaultDB, TB extends keyof TBD = a
      if (options.where) {
         // @todo: auto-alias base entity when using joins! otherwise "id" is ambiguous
         const aliases = [entity.name];
-         if (validated.join.length > 0) {
+         if (validated.join?.length > 0) {
            aliases.push(...JoinBuilder.getJoinedEntityNames(this.em, entity, validated.join));
         }

@@ -345,7 +344,7 @@ export class Repository<TBD extends object = DefaultDB, TB extends keyof TBD = a
         ...refQueryOptions,
         where: {
            ...refQueryOptions.where,
-            ..._options?.where,
+            ...(_options?.where ?? {}),
         },
      };

--- a/app/src/data/entities/query/WhereBuilder.ts
+++ b/app/src/data/entities/query/WhereBuilder.ts
@@ -6,7 +6,7 @@ import {
   isBooleanLike,
   isPrimitive,
   makeValidator,
-} from "core";
+} from "core/object/query/query";
 import type {
   DeleteQueryBuilder,
   ExpressionBuilder,
--- a/app/src/data/entities/query/WithBuilder.ts
+++ b/app/src/data/entities/query/WithBuilder.ts
@@ -1,7 +1,9 @@
 import { isObject } from "core/utils";
-import type { KyselyJsonFrom, RepoQuery } from "data";
+
+import type { KyselyJsonFrom } from "data/relations/EntityRelation";
+import type { RepoQuery } from "data/server/query";
 import { InvalidSearchParamsException } from "data/errors";
-import type { Entity, EntityManager, RepositoryQB } from "../../entities";
+import type { Entity, EntityManager, RepositoryQB } from "data/entities";

 export class WithBuilder {
   static addClause(
--- a/app/src/data/errors.ts
+++ b/app/src/data/errors.ts
@@ -1,5 +1,5 @@
-import { Exception } from "core";
-import { HttpStatus, type TypeInvalidError } from "core/utils";
+import { Exception } from "core/errors";
+import { type InvalidSchemaError, HttpStatus } from "bknd/utils";
 import type { Entity } from "./entities";
 import type { Field } from "./fields";

@@ -42,11 +42,11 @@ export class InvalidFieldConfigException extends Exception {
   constructor(
      field: Field<any, any, any>,
      public given: any,
-      error: TypeInvalidError,
+      error: InvalidSchemaError,
   ) {
      console.error("InvalidFieldConfigException", {
         given,
-         error: error.firstToString(),
+         error: error.first(),
      });
      super(`Invalid Field config given for field "${field.name}": ${error.firstToString()}`);
   }
--- a/app/src/data/events/index.ts
+++ b/app/src/data/events/index.ts
@@ -1,5 +1,5 @@
-import type { PrimaryFieldType } from "core";
-import { $console } from "core/utils";
+import type { PrimaryFieldType } from "bknd";
+import { $console } from "bknd/utils";
 import { Event, InvalidEventReturn } from "core/events";
 import type { Entity, EntityData } from "../entities";
 import type { RepoQuery } from "data/server/query";
--- a/app/src/data/fields/BooleanField.ts
+++ b/app/src/data/fields/BooleanField.ts
@@ -1,18 +1,18 @@
-import type { Static } from "core/utils";
-import type { EntityManager } from "data";
+import { omitKeys } from "core/utils";
+import type { EntityManager } from "data/entities";
 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 "bknd/utils";

-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 }),
+      default_value: s.boolean(),
+      ...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 +86,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() {
--- a/app/src/data/fields/DateField.ts
+++ b/app/src/data/fields/DateField.ts
@@ -1,26 +1,21 @@
-import { $console, type Static, StringEnum, dayjs } from "core/utils";
+import { dayjs } from "core/utils";
 import type { EntityManager } from "../entities";
 import { Field, type TActionContext, type TRenderContext, baseFieldConfigSchema } from "./Field";
-import * as tbbox from "@sinclair/typebox";
+import { $console } from "core/utils";
 import type { TFieldTSType } from "data/entities/EntityTypescript";
-const { Type } = tbbox;
+import { s } from "bknd/utils";

-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(),
+      ...baseFieldConfigSchema.properties,
+   })
+   .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,
@@ -142,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 {
--- a/app/src/data/fields/EnumField.ts
+++ b/app/src/data/fields/EnumField.ts
@@ -1,50 +1,33 @@
-import { Const, type Static, StringEnum } from "core/utils";
-import type { EntityManager } from "data";
+import { omitKeys } from "core/utils";
+import type { EntityManager } from "data/entities";
 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 "bknd/utils";

-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(),
         }),
      );
--- a/app/src/data/fields/Field.ts
+++ b/app/src/data/fields/Field.ts
@@ -1,18 +1,9 @@
-import {
-   parse,
-   snakeToPascalWithSpaces,
-   type Static,
-   StringEnum,
-   type TSchema,
-   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";
 import type { TFieldTSType } from "data/entities/EntityTypescript";
-const { Type } = tbbox;
+import { s, parse, InvalidSchemaError, snakeToPascalWithSpaces } from "bknd/utils";

 // @todo: contexts need to be reworked
 // e.g. "table" is irrelevant, because if read is not given, it fails
@@ -31,43 +22,26 @@ 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,
-            },
-         ),
-      ),
-      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,
-            },
-         ),
-      ),
+export const baseFieldConfigSchema = s
+   .strictObject({
+      label: s.string(),
+      description: s.string(),
+      required: s.boolean({ default: false }),
+      fillable: s.anyOf([
+         s.boolean({ title: "Boolean" }),
+         s.array(s.string({ enum: ActionContext }), { title: "Context", uniqueItems: true }),
+      ]),
+      hidden: s.anyOf([
+         s.boolean({ title: "Boolean" }),
+         // @todo: tmp workaround
+         s.array(s.string({ enum: TmpContext }), { title: "Context", uniqueItems: true }),
+      ]),
      // 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 +66,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 +78,7 @@ export abstract class Field<
      return this.type;
   }

-   protected abstract getSchema(): TSchema;
+   protected abstract getSchema(): s.ObjectSchema;

   /**
    * Used in SchemaManager.ts
@@ -115,7 +89,9 @@ export abstract class Field<
         name: this.name,
         type: "text",
         nullable: true,
-         dflt: this.getDefault(),
+         // see field-test-suite.ts:41
+         dflt: undefined,
+         //dflt: this.getDefault(),
      });
   }

@@ -131,14 +107,14 @@ export abstract class Field<
      if (Array.isArray(this.config.fillable)) {
         return context ? this.config.fillable.includes(context) : DEFAULT_FILLABLE;
      }
-      return !!this.config.fillable;
+      return this.config.fillable ?? DEFAULT_FILLABLE;
   }

   isHidden(context?: TmpActionAndRenderContext): boolean {
      if (Array.isArray(this.config.hidden)) {
         return context ? this.config.hidden.includes(context as any) : DEFAULT_HIDDEN;
      }
-      return this.config.hidden ?? false;
+      return this.config.hidden ?? DEFAULT_HIDDEN;
   }

   isRequired(): boolean {
@@ -224,16 +200,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 {
--- a/app/src/data/fields/JsonField.ts
+++ b/app/src/data/fields/JsonField.ts
@@ -1,14 +1,18 @@
-import type { Static } from "core/utils";
-import type { EntityManager } from "data";
+import { omitKeys } from "core/utils";
+import type { EntityManager } from "data/entities";
 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 "bknd/utils";

-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,
--- a/app/src/data/fields/JsonSchemaField.ts
+++ b/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 type { EntityManager } from "data";
+import { objectToJsLiteral } from "core/utils";
+import type { EntityManager } from "data/entities";
 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 "bknd/utils";

-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" }),
+      ui_schema: s.any({ type: "object" }),
+      default_from_schema: s.boolean(),
+      ...baseFieldConfigSchema.properties,
+   })
+   .partial();

-export type JsonSchemaFieldConfig = Static<typeof jsonSchemaFieldConfigSchema>;
+export type JsonSchemaFieldConfig = s.Static<typeof jsonSchemaFieldConfigSchema>;

 export class JsonSchemaField<
   Required extends true | false = false,
@@ -32,7 +26,7 @@ export class JsonSchemaField<

   constructor(name: string, config: Partial<JsonSchemaFieldConfig>) {
      super(name, config);
-      this.validator = new Validator(this.getJsonSchema());
+      this.validator = new Validator({ ...this.getJsonSchema() });
   }

   protected getSchema() {
@@ -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,
         }),
--- a/app/src/data/fields/NumberField.ts
+++ b/app/src/data/fields/NumberField.ts
@@ -1,29 +1,23 @@
-import type { Static } from "core/utils";
-import type { EntityManager } from "data";
+import type { EntityManager } from "data/entities";
 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 "bknd/utils";
+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,
--- a/app/src/data/fields/PrimaryField.ts
+++ b/app/src/data/fields/PrimaryField.ts
@@ -1,22 +1,20 @@
-import { config } from "core";
-import { StringEnum, uuidv7, type Static } from "core/utils";
+import { config } from "core/config";
+import { omitKeys, uuidv7, s } from "bknd/utils";
 import { Field, baseFieldConfigSchema } from "./Field";
-import * as tbbox from "@sinclair/typebox";
 import type { TFieldTSType } from "data/entities/EntityTypescript";
-const { Type } = tbbox;

 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,
@@ -26,7 +24,7 @@ export class PrimaryField<Required extends true | false = false> extends Field<
   override readonly type = "primary";

   constructor(name: string = config.data.default_primary_field, cfg?: PrimaryFieldConfig) {
-      super(name, { fillable: false, required: false, ...cfg });
+      super(name, { ...cfg, fillable: false, required: false });
   }

   override isRequired(): boolean {
@@ -41,7 +39,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 +65,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 {
--- a/app/src/data/fields/TextField.ts
+++ b/app/src/data/fields/TextField.ts
@@ -1,42 +1,24 @@
-import type { EntityManager } from "data";
-import type { Static } from "core/utils";
+import type { EntityManager } from "data/entities";
+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 "bknd/utils";

-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.partialObject({
+         element: s.string(),
+         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,
--- a/app/src/data/fields/VirtualField.ts
+++ b/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 "bknd/utils";

-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,
         }),
--- a/app/src/data/fields/field-test-suite.ts
+++ b/app/src/data/fields/field-test-suite.ts
@@ -1,4 +1,4 @@
-import type { BaseFieldConfig, Field, TActionContext } from "data";
+import type { BaseFieldConfig, Field, TActionContext } from "data/fields";
 import type { ColumnDataType } from "kysely";
 import { omit } from "lodash-es";
 import type { TestRunner } from "core/test";
@@ -50,7 +50,7 @@ export function fieldTestSuite(
      expect(noConfigField.hasDefault()).toBe(false);
      expect(noConfigField.getDefault()).toBeUndefined();
      expect(dflt.hasDefault()).toBe(true);
-      expect(dflt.getDefault()).toBe(config.defaultValue);
+      expect(dflt.getDefault()).toEqual(config.defaultValue);
   });

   test("isFillable", async () => {
@@ -98,9 +98,7 @@ export function fieldTestSuite(
   test("toJSON", async () => {
      const _config = {
         ..._requiredConfig,
-         fillable: true,
         required: false,
-         hidden: false,
      };

      function fieldJson(field: Field) {
@@ -118,7 +116,10 @@ export function fieldTestSuite(

      expect(fieldJson(fillable)).toEqual({
         type: noConfigField.type,
-         config: _config,
+         config: {
+            ..._config,
+            fillable: true,
+         },
      });

      expect(fieldJson(required)).toEqual({
--- a/app/src/data/helper.ts
+++ b/app/src/data/helper.ts
@@ -1,4 +1,5 @@
-import type { EntityData, EntityManager, Field } from "data";
+import type { EntityData, EntityManager } from "data/entities";
+import type { Field } from "data/fields";
 import { transform } from "lodash-es";

 export function getDefaultValues(fields: Field[], data: EntityData): EntityData {
--- a/app/src/data/index.ts
+++ b/app/src/data/index.ts
@@ -1,45 +0,0 @@
-import { MutatorEvents, RepositoryEvents } from "./events";
-
-export * from "./fields";
-export * from "./entities";
-export * from "./relations";
-export * from "./schema/SchemaManager";
-export * from "./prototype";
-export * from "./connection";
-
-export {
-   type RepoQuery,
-   type RepoQueryIn,
-   getRepoQueryTemplate,
-   repoQuery,
-} from "./server/query";
-
-export type { WhereQuery } from "./entities/query/WhereBuilder";
-
-export { KyselyPluginRunner } from "./plugins/KyselyPluginRunner";
-
-export { constructEntity, constructRelation } from "./schema/constructor";
-
-export const DatabaseEvents = {
-   ...MutatorEvents,
-   ...RepositoryEvents,
-};
-export { MutatorEvents, RepositoryEvents };
-
-export * as DataPermissions from "./permissions";
-
-export { MediaField, type MediaFieldConfig, type MediaItem } from "media/MediaField";
-
-export { libsql } from "./connection/sqlite/libsql/LibsqlConnection";
-export {
-   genericSqlite,
-   genericSqliteUtils,
-   type GenericSqliteConnection,
-} from "./connection/sqlite/GenericSqliteConnection";
-
-export {
-   EntityTypescript,
-   type EntityTypescriptOptions,
-   type TEntityTSType,
-   type TFieldTSType,
-} from "./entities/EntityTypescript";
--- a/app/src/data/permissions/index.ts
+++ b/app/src/data/permissions/index.ts
@@ -1,4 +1,4 @@
-import { Permission } from "core";
+import { Permission } from "core/security/Permission";

 export const entityRead = new Permission("data.entity.read");
 export const entityCreate = new Permission("data.entity.create");
--- a/app/src/data/relations/EntityRelation.ts
+++ b/app/src/data/relations/EntityRelation.ts
@@ -1,4 +1,5 @@
-import { type Static, parse } from "core/utils";
+import type { PrimaryFieldType } from "bknd";
+import { s, parse } from "bknd/utils";
 import type { ExpressionBuilder, SelectQueryBuilder } from "kysely";
 import type { Entity, EntityData, EntityManager } from "../entities";
 import {
@@ -8,9 +9,6 @@ import {
 } from "../relations";
 import type { RepoQuery } from "../server/query";
 import type { RelationType } from "./relation-types";
-import * as tbbox from "@sinclair/typebox";
-import type { PrimaryFieldType } from "core";
-const { Type } = tbbox;

 const directions = ["source", "target"] as const;
 export type TDirection = (typeof directions)[number];
@@ -18,13 +16,13 @@ export type TDirection = (typeof directions)[number];
 export type KyselyJsonFrom = any;
 export type KyselyQueryBuilder = SelectQueryBuilder<any, any, any>;

-export type BaseRelationConfig = Static<typeof EntityRelation.schema>;
+export type BaseRelationConfig = s.Static<typeof EntityRelation.schema>;

 // @todo: add generic type for relation config
 export abstract class EntityRelation<
   Schema extends typeof EntityRelation.schema = typeof EntityRelation.schema,
 > {
-   config: Static<Schema>;
+   config: s.Static<Schema>;

   source: EntityRelationAnchor;
   target: EntityRelationAnchor;
@@ -33,17 +31,17 @@ export abstract class EntityRelation<
   // allowed directions, used in RelationAccessor for visibility
   directions: TDirection[] = ["source", "target"];

-   static schema = Type.Object({
-      mappedBy: Type.Optional(Type.String()),
-      inversedBy: Type.Optional(Type.String()),
-      required: Type.Optional(Type.Boolean()),
+   static schema = s.strictObject({
+      mappedBy: s.string().optional(),
+      inversedBy: s.string().optional(),
+      required: s.boolean().optional(),
   });

   // don't make protected, App requires it to instantiatable
   constructor(
      source: EntityRelationAnchor,
      target: EntityRelationAnchor,
-      config: Partial<Static<Schema>> = {},
+      config: Partial<s.Static<Schema>> = {},
   ) {
      this.source = source;
      this.target = target;
--- a/app/src/data/relations/ManyToManyRelation.ts
+++ b/app/src/data/relations/ManyToManyRelation.ts
@@ -1,4 +1,3 @@
-import type { Static } from "core/utils";
 import type { ExpressionBuilder } from "kysely";
 import { Entity, type EntityManager } from "../entities";
 import { type Field, PrimaryField } from "../fields";
@@ -7,10 +6,9 @@ import { EntityRelation, type KyselyQueryBuilder } from "./EntityRelation";
 import { EntityRelationAnchor } from "./EntityRelationAnchor";
 import { RelationField } from "./RelationField";
 import { type RelationType, RelationTypes } from "./relation-types";
-import * as tbbox from "@sinclair/typebox";
-const { Type } = tbbox;
+import { s } from "bknd/utils";

-export type ManyToManyRelationConfig = Static<typeof ManyToManyRelation.schema>;
+export type ManyToManyRelationConfig = s.Static<typeof ManyToManyRelation.schema>;

 export class ManyToManyRelation extends EntityRelation<typeof ManyToManyRelation.schema> {
   connectionEntity: Entity;
@@ -18,18 +16,11 @@ export class ManyToManyRelation extends EntityRelation<typeof ManyToManyRelation
   connectionTableMappedName: string;
   private em?: EntityManager<any>;

-   static override schema = Type.Composite(
-      [
-         EntityRelation.schema,
-         Type.Object({
-            connectionTable: Type.Optional(Type.String()),
-            connectionTableMappedName: Type.Optional(Type.String()),
-         }),
-      ],
-      {
-         additionalProperties: false,
-      },
-   );
+   static override schema = s.strictObject({
+      connectionTable: s.string().optional(),
+      connectionTableMappedName: s.string().optional(),
+      ...EntityRelation.schema.properties,
+   });

   constructor(
      source: Entity,
--- a/app/src/data/relations/ManyToOneRelation.ts
+++ b/app/src/data/relations/ManyToOneRelation.ts
@@ -1,6 +1,5 @@
-import type { PrimaryFieldType } from "core";
-import { snakeToPascalWithSpaces } from "core/utils";
-import type { Static } from "core/utils";
+import type { PrimaryFieldType } from "bknd";
+import { snakeToPascalWithSpaces, s } from "bknd/utils";
 import type { ExpressionBuilder } from "kysely";
 import type { Entity, EntityManager } from "../entities";
 import type { RepoQuery } from "../server/query";
@@ -9,8 +8,6 @@ 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
@@ -20,7 +17,7 @@ const { Type } = tbbox;
 *    posts gets a users_id field
 */

-export type ManyToOneRelationConfig = Static<typeof ManyToOneRelation.schema>;
+export type ManyToOneRelationConfig = s.Static<typeof ManyToOneRelation.schema>;

 export class ManyToOneRelation extends EntityRelation<typeof ManyToOneRelation.schema> {
   private fieldConfig?: RelationFieldBaseConfig;
@@ -28,30 +25,21 @@ export class ManyToOneRelation extends EntityRelation<typeof ManyToOneRelation.s
      with_limit: 5,
   };

-   static override schema = Type.Composite(
-      [
-         EntityRelation.schema,
-         Type.Object({
-            sourceCardinality: Type.Optional(Type.Number()),
-            with_limit: Type.Optional(
-               Type.Number({ default: ManyToOneRelation.DEFAULTS.with_limit }),
-            ),
-            fieldConfig: Type.Optional(
-               Type.Object({
-                  label: Type.String(),
-               }),
-            ),
-         }),
-      ],
-      {
-         additionalProperties: false,
-      },
-   );
+   static override schema = s.strictObject({
+      sourceCardinality: s.number().optional(),
+      with_limit: s.number({ default: ManyToOneRelation.DEFAULTS.with_limit }).optional(),
+      fieldConfig: s
+         .object({
+            label: s.string(),
+         })
+         .optional(),
+      ...EntityRelation.schema.properties,
+   });

   constructor(
      source: Entity,
      target: Entity,
-      config: Partial<Static<typeof ManyToOneRelation.schema>> = {},
+      config: Partial<s.Static<typeof ManyToOneRelation.schema>> = {},
   ) {
      const mappedBy = config.mappedBy || target.name;
      const inversedBy = config.inversedBy || source.name;
--- a/app/src/data/relations/PolymorphicRelation.ts
+++ b/app/src/data/relations/PolymorphicRelation.ts
@@ -1,4 +1,3 @@
-import type { Static } from "core/utils";
 import type { ExpressionBuilder } from "kysely";
 import type { Entity, EntityManager } from "../entities";
 import { NumberField, TextField } from "../fields";
@@ -6,24 +5,16 @@ import type { RepoQuery } from "../server/query";
 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;
+import { s } from "bknd/utils";

-export type PolymorphicRelationConfig = Static<typeof PolymorphicRelation.schema>;
+export type PolymorphicRelationConfig = s.Static<typeof PolymorphicRelation.schema>;

 // @todo: what about cascades?
 export class PolymorphicRelation extends EntityRelation<typeof PolymorphicRelation.schema> {
-   static override schema = Type.Composite(
-      [
-         EntityRelation.schema,
-         Type.Object({
-            targetCardinality: Type.Optional(Type.Number()),
-         }),
-      ],
-      {
-         additionalProperties: false,
-      },
-   );
+   static override schema = s.strictObject({
+      targetCardinality: s.number().optional(),
+      ...EntityRelation.schema.properties,
+   });

   constructor(source: Entity, target: Entity, config: Partial<PolymorphicRelationConfig> = {}) {
      const mappedBy = config.mappedBy || target.name;
--- a/app/src/data/relations/RelationField.ts
+++ b/app/src/data/relations/RelationField.ts
@@ -1,26 +1,22 @@
-import { type Static, StringEnum } from "core/utils";
 import type { EntityManager } from "../entities";
-import { Field, baseFieldConfigSchema, primaryFieldTypes } from "../fields";
+import { Field, baseFieldConfigSchema } from "../fields";
 import type { EntityRelation } from "./EntityRelation";
 import type { EntityRelationAnchor } from "./EntityRelationAnchor";
-import * as tbbox from "@sinclair/typebox";
 import type { TFieldTSType } from "data/entities/EntityTypescript";
-const { Type } = tbbox;
+import { s } from "bknd/utils";

 const CASCADES = ["cascade", "set null", "set default", "restrict", "no action"] as const;

-export const relationFieldConfigSchema = Type.Composite([
-   baseFieldConfigSchema,
-   Type.Object({
-      reference: Type.String(),
-      target: Type.String(), // @todo: potentially has to be an instance!
-      target_field: Type.Optional(Type.String({ default: "id" })),
-      target_field_type: Type.Optional(StringEnum(["integer", "text"], { default: "integer" })),
-      on_delete: Type.Optional(StringEnum(CASCADES, { default: "set null" })),
-   }),
-]);
+export const relationFieldConfigSchema = s.strictObject({
+   reference: s.string(),
+   target: s.string(), // @todo: potentially has to be an instance!
+   target_field: s.string({ default: "id" }).optional(),
+   target_field_type: s.string({ enum: ["text", "integer"], default: "integer" }).optional(),
+   on_delete: s.string({ enum: CASCADES, default: "set null" }).optional(),
+   ...baseFieldConfigSchema.properties,
+});

-export type RelationFieldConfig = Static<typeof relationFieldConfigSchema>;
+export type RelationFieldConfig = s.Static<typeof relationFieldConfigSchema>;
 export type RelationFieldBaseConfig = { label?: string };

 export class RelationField extends Field<RelationFieldConfig> {
@@ -81,7 +77,7 @@ export class RelationField extends Field<RelationFieldConfig> {

   override toJsonSchema() {
      return this.toSchemaWrapIfRequired(
-         Type.Number({
+         s.number({
            $ref: `${this.config?.target}#/properties/${this.config?.target_field}`,
         }),
      );
--- a/app/src/data/relations/RelationMutator.ts
+++ b/app/src/data/relations/RelationMutator.ts
@@ -1,4 +1,4 @@
-import type { PrimaryFieldType } from "core";
+import type { PrimaryFieldType } from "bknd";
 import type { Entity, EntityManager } from "../entities";
 import {
   type EntityRelation,
--- a/app/src/data/schema/SchemaManager.ts
+++ b/app/src/data/schema/SchemaManager.ts
@@ -1,8 +1,8 @@
 import type { CompiledQuery, TableMetadata } from "kysely";
-import type { IndexMetadata, SchemaResponse } from "../connection/Connection";
-import type { Entity, EntityManager } from "../entities";
-import { PrimaryField } from "../fields";
-import { $console } from "core/utils";
+import type { IndexMetadata, SchemaResponse } from "data/connection/Connection";
+import type { Entity, EntityManager } from "data/entities";
+import { PrimaryField } from "data/fields";
+import { $console } from "bknd/utils";

 type IntrospectedTable = TableMetadata & {
   indices: IndexMetadata[];
--- a/app/src/data/schema/constructor.ts
+++ b/app/src/data/schema/constructor.ts
@@ -1,5 +1,6 @@
 import { transformObject } from "core/utils";
-import { Entity, type Field } from "data";
+import { Entity } from "data/entities";
+import type { Field } from "data/fields";
 import { FIELDS, RELATIONS, type TAppDataEntity, type TAppDataRelation } from "data/data-schema";

 export function constructEntity(name: string, entityConfig: TAppDataEntity) {
--- a/app/src/data/server/query.spec.ts
+++ b/app/src/data/server/query.spec.ts
@@ -1,8 +1,12 @@
 import { test, describe, expect } from "bun:test";
 import * as q from "./query";
-import { s as schema, parse as $parse, type ParseOptions } from "core/object/schema";
+import { parse as $parse, type ParseOptions } from "bknd/utils";

-const parse = (v: unknown, o: ParseOptions = {}) => $parse(q.repoQuery, v, o);
+const parse = (v: unknown, o: ParseOptions = {}) =>
+   $parse(q.repoQuery, v, {
+      ...o,
+      withDefaults: false,
+   });

 // compatibility
 const decode = (input: any, output: any) => {
@@ -11,7 +15,7 @@ const decode = (input: any, output: any) => {

 describe("server/query", () => {
   test("limit & offset", () => {
-      expect(() => parse({ limit: false })).toThrow();
+      //expect(() => parse({ limit: false })).toThrow();
      expect(parse({ limit: "11" })).toEqual({ limit: 11 });
      expect(parse({ limit: 20 })).toEqual({ limit: 20 });
      expect(parse({ offset: "1" })).toEqual({ offset: 1 });
@@ -44,6 +48,7 @@ describe("server/query", () => {
      });
      expect(parse({ sort: { by: "title" } }).sort).toEqual({
         by: "title",
+         dir: "asc",
      });
      expect(
         parse(
@@ -102,9 +107,12 @@ describe("server/query", () => {

   test("template", () => {
      expect(
-         q.repoQuery.template({
-            withOptional: true,
-         }),
+         q.repoQuery.template(
+            {},
+            {
+               withOptional: true,
+            },
+         ),
      ).toEqual({
         limit: 10,
         offset: 0,
--- a/app/src/data/server/query.ts
+++ b/app/src/data/server/query.ts
@@ -1,7 +1,7 @@
-import { s } from "core/object/schema";
+import { s } from "bknd/utils";
 import { WhereBuilder, type WhereQuery } from "data/entities/query/WhereBuilder";
 import { isObject, $console } from "core/utils";
-import type { CoercionOptions, TAnyOf } from "jsonv-ts";
+import type { anyOf, CoercionOptions, Schema } from "jsonv-ts";

 // -------
 // helpers
@@ -35,10 +35,12 @@ const stringArray = s.anyOf(
 // -------
 // sorting
 const sortDefault = { by: "id", dir: "asc" };
-const sortSchema = s.object({
-   by: s.string(),
-   dir: s.string({ enum: ["asc", "desc"] }).optional(),
-});
+const sortSchema = s
+   .object({
+      by: s.string(),
+      dir: s.string({ enum: ["asc", "desc"] }).optional(),
+   })
+   .strict();
 type SortSchema = s.Static<typeof sortSchema>;
 const sort = s.anyOf([s.string(), sortSchema], {
   default: sortDefault,
@@ -48,11 +50,19 @@ const sort = s.anyOf([s.string(), sortSchema], {
            const dir = v[0] === "-" ? "desc" : "asc";
            return { by: dir === "desc" ? v.slice(1) : v, dir } as any;
         } else if (/^{.*}$/.test(v)) {
-            return JSON.parse(v) as any;
+            return {
+               ...sortDefault,
+               ...JSON.parse(v),
+            } as any;
         }

         $console.warn(`Invalid sort given: '${JSON.stringify(v)}'`);
         return sortDefault as any;
+      } else if (isObject(v)) {
+         return {
+            ...sortDefault,
+            ...v,
+         } as any;
      }
      return v as any;
   },
@@ -87,9 +97,9 @@ export type RepoWithSchema = Record<
   }
 >;

-const withSchema = <In, Out = In>(self: s.TSchema): s.TSchemaInOut<In, Out> =>
+const withSchema = <Type = unknown>(self: Schema): Schema<{}, Type, Type> =>
   s.anyOf([stringIdentifier, s.array(stringIdentifier), self], {
-      coerce: function (this: TAnyOf<any>, _value: unknown, opts: CoercionOptions = {}) {
+      coerce: function (this: typeof anyOf, _value: unknown, opts: CoercionOptions = {}) {
         let value: any = _value;

         if (typeof value === "string") {
@@ -125,20 +135,25 @@ const withSchema = <In, Out = In>(self: s.TSchema): s.TSchemaInOut<In, Out> =>
 // ==========
 // REPO QUERY
 export const repoQuery = s.recursive((self) =>
-   s.partialObject({
-      limit: s.number({ default: 10 }),
-      offset: s.number({ default: 0 }),
-      sort,
-      where,
-      select: stringArray,
-      join: stringArray,
-      with: withSchema<RepoWithSchema>(self),
-   }),
+   s
+      .object({
+         limit: s.number({ default: 10 }),
+         offset: s.number({ default: 0 }),
+         sort,
+         where,
+         select: stringArray,
+         join: stringArray,
+         with: withSchema<RepoWithSchema>(self),
+      })
+      .partial(),
 );
 export const getRepoQueryTemplate = () =>
-   repoQuery.template({
-      withOptional: true,
-   }) as Required<RepoQuery>;
+   repoQuery.template(
+      {},
+      {
+         withOptional: true,
+      },
+   ) as Required<RepoQuery>;

 export type RepoQueryIn = {
   limit?: number;
@@ -152,3 +167,15 @@ export type RepoQueryIn = {
 export type RepoQuery = s.StaticCoerced<typeof repoQuery> & {
   sort: SortSchema;
 };
+
+//export type RepoQuery = s.StaticCoerced<typeof repoQuery>;
+// @todo: CURRENT WORKAROUND
+/* export type RepoQuery = {
+   limit?: number;
+   offset?: number;
+   sort?: { by: string; dir: "asc" | "desc" };
+   select?: string[];
+   with?: Record<string, RepoQuery>;
+   join?: string[];
+   where?: WhereQuery;
+}; */