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>
This commit is contained in:
dswbx
2025-08-01 15:55:59 +02:00
committed by GitHub
parent daaaae82b6
commit a298b65abf
430 changed files with 15041 additions and 12375 deletions

View File

@@ -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() {

View File

@@ -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 {

View File

@@ -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(),
}),
);

View File

@@ -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 {

View File

@@ -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,

View File

@@ -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,
}),

View File

@@ -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,

View File

@@ -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 {

View File

@@ -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,

View File

@@ -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,
}),

View File

@@ -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({