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,15 +1,15 @@
import { type Static, transformObject } from "core/utils";
import { Flow, HttpTrigger } from "flows";
import { Hono } from "hono";
import { Module } from "modules/Module";
import { TASKS, flowsConfigSchema } from "./flows-schema";
import { type s, transformObject } from "bknd/utils";
export type AppFlowsSchema = Static<typeof flowsConfigSchema>;
export type AppFlowsSchema = s.Static<typeof flowsConfigSchema>;
export type TAppFlowSchema = AppFlowsSchema["flows"][number];
export type TAppFlowTriggerSchema = TAppFlowSchema["trigger"];
export type { TAppFlowTaskSchema } from "./flows-schema";
export class AppFlows extends Module<typeof flowsConfigSchema> {
export class AppFlows extends Module<AppFlowsSchema> {
private flows: Record<string, Flow> = {};
getSchema() {
@@ -80,6 +80,8 @@ export class AppFlows extends Module<typeof flowsConfigSchema> {
this.setBuilt();
}
// @todo: fix this
// @ts-expect-error
override toJSON() {
return {
...this.config,

View File

@@ -1,7 +1,6 @@
import { Const, type Static, StringRecord, transformObject } from "core/utils";
import { transformObject } from "core/utils";
import { TaskMap, TriggerMap } from "flows";
import * as tbbox from "@sinclair/typebox";
const { Type } = tbbox;
import { s } from "bknd/utils";
export const TASKS = {
...TaskMap,
@@ -10,77 +9,59 @@ export const TASKS = {
export const TRIGGERS = TriggerMap;
const taskSchemaObject = transformObject(TASKS, (task, name) => {
return Type.Object(
return s.strictObject(
{
type: Const(name),
type: s.literal(name),
params: task.cls.schema,
},
{ title: String(name), additionalProperties: false },
{ title: String(name) },
);
});
const taskSchema = Type.Union(Object.values(taskSchemaObject));
export type TAppFlowTaskSchema = Static<typeof taskSchema>;
const taskSchema = s.anyOf(Object.values(taskSchemaObject));
export type TAppFlowTaskSchema = s.Static<typeof taskSchema>;
const triggerSchemaObject = transformObject(TRIGGERS, (trigger, name) => {
return Type.Object(
return s.strictObject(
{
type: Const(name),
config: trigger.cls.schema,
type: s.literal(name),
config: trigger.cls.schema.optional(),
},
{ title: String(name), additionalProperties: false },
{ title: String(name) },
);
});
const triggerSchema = s.anyOf(Object.values(triggerSchemaObject));
export type TAppFlowTriggerSchema = s.Static<typeof triggerSchema>;
const connectionSchema = Type.Object({
source: Type.String(),
target: Type.String(),
config: Type.Object(
{
condition: Type.Optional(
Type.Union([
Type.Object(
{ type: Const("success") },
{ additionalProperties: false, title: "success" },
),
Type.Object(
{ type: Const("error") },
{ additionalProperties: false, title: "error" },
),
Type.Object(
{ type: Const("matches"), path: Type.String(), value: Type.String() },
{ additionalProperties: false, title: "matches" },
),
]),
),
max_retries: Type.Optional(Type.Number()),
},
{ default: {}, additionalProperties: false },
),
const connectionSchema = s.strictObject({
source: s.string(),
target: s.string(),
config: s
.strictObject({
condition: s.anyOf([
s.strictObject({ type: s.literal("success") }, { title: "success" }),
s.strictObject({ type: s.literal("error") }, { title: "error" }),
s.strictObject(
{ type: s.literal("matches"), path: s.string(), value: s.string() },
{ title: "matches" },
),
]),
max_retries: s.number(),
})
.partial(),
});
// @todo: rework to have fixed ids per task and connections (and preferrably arrays)
// causes issues with canvas
export const flowSchema = Type.Object(
{
trigger: Type.Union(Object.values(triggerSchemaObject)),
tasks: Type.Optional(StringRecord(Type.Union(Object.values(taskSchemaObject)))),
connections: Type.Optional(StringRecord(connectionSchema)),
start_task: Type.Optional(Type.String()),
responding_task: Type.Optional(Type.String()),
},
{
additionalProperties: false,
},
);
export type TAppFlowSchema = Static<typeof flowSchema>;
export const flowSchema = s.strictObject({
trigger: s.anyOf(Object.values(triggerSchemaObject)),
tasks: s.record(s.anyOf(Object.values(taskSchemaObject))).optional(),
connections: s.record(connectionSchema).optional(),
start_task: s.string().optional(),
responding_task: s.string().optional(),
});
export type TAppFlowSchema = s.Static<typeof flowSchema>;
export const flowsConfigSchema = Type.Object(
{
basepath: Type.String({ default: "/api/flows" }),
flows: StringRecord(flowSchema, { default: {} }),
},
{
default: {},
additionalProperties: false,
},
);
export const flowsConfigSchema = s.strictObject({
basepath: s.string({ default: "/api/flows" }),
flows: s.record(flowSchema, { default: {} }),
});

View File

@@ -2,19 +2,15 @@ import type { EventManager } from "core/events";
import type { Flow } from "../Flow";
import { Trigger } from "./Trigger";
import { $console } from "core/utils";
import * as tbbox from "@sinclair/typebox";
const { Type } = tbbox;
import { s } from "bknd/utils";
export class EventTrigger extends Trigger<typeof EventTrigger.schema> {
override type = "event";
static override schema = Type.Composite([
Trigger.schema,
Type.Object({
event: Type.String(),
// add match
}),
]);
static override schema = s.strictObject({
event: s.string(),
...Trigger.schema.properties,
});
override async register(flow: Flow, emgr: EventManager<any>) {
if (!emgr.eventExists(this.config.event)) {

View File

@@ -1,23 +1,19 @@
import { StringEnum } from "core/utils";
import type { Context, Hono } from "hono";
import type { Flow } from "../Flow";
import { Trigger } from "./Trigger";
import * as tbbox from "@sinclair/typebox";
const { Type } = tbbox;
import { s } from "bknd/utils";
const httpMethods = ["GET", "POST", "PUT", "PATCH", "DELETE"] as const;
export class HttpTrigger extends Trigger<typeof HttpTrigger.schema> {
override type = "http";
static override schema = Type.Composite([
Trigger.schema,
Type.Object({
path: Type.String({ pattern: "^/.*$" }),
method: StringEnum(httpMethods, { default: "GET" }),
response_type: StringEnum(["json", "text", "html"], { default: "json" }),
}),
]);
static override schema = s.strictObject({
path: s.string({ pattern: "^/.*$" }),
method: s.string({ enum: httpMethods, default: "GET" }),
response_type: s.string({ enum: ["json", "text", "html"], default: "json" }),
...Trigger.schema.properties,
});
override async register(flow: Flow, hono: Hono<any>) {
const method = this.config.method.toLowerCase() as any;

View File

@@ -1,20 +1,18 @@
import { type Static, StringEnum, parse } from "core/utils";
import type { Execution } from "../Execution";
import type { Flow } from "../Flow";
import * as tbbox from "@sinclair/typebox";
const { Type } = tbbox;
import { s, parse } from "bknd/utils";
export class Trigger<Schema extends typeof Trigger.schema = typeof Trigger.schema> {
// @todo: remove this
executions: Execution[] = [];
type = "manual";
config: Static<Schema>;
config: s.Static<Schema>;
static schema = Type.Object({
mode: StringEnum(["sync", "async"], { default: "async" }),
static schema = s.strictObject({
mode: s.string({ enum: ["sync", "async"], default: "async" }),
});
constructor(config?: Partial<Static<Schema>>) {
constructor(config?: Partial<s.Static<Schema>>) {
const schema = (this.constructor as typeof Trigger).schema;
// @ts-ignore for now
this.config = parse(schema, config ?? {});

View File

@@ -1,9 +1,10 @@
import type { StaticDecode, TSchema } from "@sinclair/typebox";
import { BkndError, SimpleRenderer } from "core";
import { type Static, type TObject, Value, parse, ucFirst } from "core/utils";
//import { BkndError, SimpleRenderer } from "core";
import { BkndError } from "core/errors";
import { s, parse } from "bknd/utils";
import type { InputsMap } from "../flows/Execution";
import * as tbbox from "@sinclair/typebox";
const { Type } = tbbox;
import { SimpleRenderer } from "core/template/SimpleRenderer";
//type InstanceOf<T> = T extends new (...args: any) => infer R ? R : never;
export type TaskResult<Output = any> = {
@@ -16,7 +17,9 @@ export type TaskResult<Output = any> = {
export type TaskRenderProps<T extends Task = Task> = any;
export function dynamic<Type extends TSchema>(
export const dynamic = <S extends s.Schema>(a: S, b?: any) => a;
/* export function dynamic<Type extends TSchema>(
type: Type,
parse?: (val: any | string) => Static<Type>,
) {
@@ -51,23 +54,23 @@ export function dynamic<Type extends TSchema>(
// @ts-ignore
.Encode((val) => val)
);
}
} */
export abstract class Task<Params extends TObject = TObject, Output = unknown> {
export abstract class Task<Params extends s.Schema = s.Schema, Output = unknown> {
abstract type: string;
name: string;
/**
* The schema of the task's parameters.
*/
static schema = Type.Object({});
static schema = s.any();
/**
* The task's parameters.
*/
_params: Static<Params>;
_params: s.Static<Params>;
constructor(name: string, params?: Static<Params>) {
constructor(name: string, params?: s.Static<Params>) {
if (typeof name !== "string") {
throw new Error(`Task name must be a string, got ${typeof name}`);
}
@@ -81,7 +84,7 @@ export abstract class Task<Params extends TObject = TObject, Output = unknown> {
if (
schema === Task.schema &&
typeof params !== "undefined" &&
Object.keys(params).length > 0
Object.keys(params || {}).length > 0
) {
throw new Error(
`Task "${name}" has no schema defined but params passed: ${JSON.stringify(params)}`,
@@ -93,18 +96,18 @@ export abstract class Task<Params extends TObject = TObject, Output = unknown> {
}
get params() {
return this._params as StaticDecode<Params>;
return this._params as s.StaticCoerced<Params>;
}
protected clone(name: string, params: Static<Params>): Task {
protected clone(name: string, params: s.Static<Params>): Task {
return new (this.constructor as any)(name, params);
}
static async resolveParams<S extends TSchema>(
static async resolveParams<S extends s.Schema>(
schema: S,
params: any,
inputs: object = {},
): Promise<StaticDecode<S>> {
): Promise<s.StaticCoerced<S>> {
const newParams: any = {};
const renderer = new SimpleRenderer(inputs, { renderKeys: true });
@@ -134,7 +137,8 @@ export abstract class Task<Params extends TObject = TObject, Output = unknown> {
newParams[key] = value;
}
return Value.Decode(schema, newParams);
return schema.coerce(newParams);
//return Value.Decode(schema, newParams);
}
private async cloneWithResolvedParams(_inputs: Map<string, any>) {

View File

@@ -1,7 +1,5 @@
import { StringEnum } from "core/utils";
import { Task, dynamic } from "../Task";
import * as tbbox from "@sinclair/typebox";
const { Type } = tbbox;
import { s } from "bknd/utils";
const FetchMethods = ["GET", "POST", "PUT", "PATCH", "DELETE"];
@@ -11,24 +9,22 @@ export class FetchTask<Output extends Record<string, any>> extends Task<
> {
type = "fetch";
static override schema = Type.Object({
url: Type.String({
static override schema = s.strictObject({
url: s.string({
pattern: "^(http|https)://",
}),
method: Type.Optional(dynamic(StringEnum(FetchMethods, { default: "GET" }))),
headers: Type.Optional(
dynamic(
Type.Array(
Type.Object({
key: Type.String(),
value: Type.String(),
}),
),
JSON.parse,
method: dynamic(s.string({ enum: FetchMethods, default: "GET" })).optional(),
headers: dynamic(
s.array(
s.strictObject({
key: s.string(),
value: s.string(),
}),
),
),
body: Type.Optional(dynamic(Type.String())),
normal: Type.Optional(dynamic(Type.Number(), Number.parseInt)),
JSON.parse,
).optional(),
body: dynamic(s.string()).optional(),
normal: dynamic(s.number(), Number.parseInt).optional(),
});
protected getBody(): string | undefined {

View File

@@ -1,13 +1,12 @@
import { Task } from "../Task";
import { $console } from "core/utils";
import * as tbbox from "@sinclair/typebox";
const { Type } = tbbox;
import { s } from "bknd/utils";
export class LogTask extends Task<typeof LogTask.schema> {
type = "log";
static override schema = Type.Object({
delay: Type.Number({ default: 10 }),
static override schema = s.strictObject({
delay: s.number({ default: 10 }),
});
async execute() {

View File

@@ -1,6 +1,5 @@
import { Task } from "../Task";
import * as tbbox from "@sinclair/typebox";
const { Type } = tbbox;
import { s } from "bknd/utils";
export class RenderTask<Output extends Record<string, any>> extends Task<
typeof RenderTask.schema,
@@ -8,8 +7,8 @@ export class RenderTask<Output extends Record<string, any>> extends Task<
> {
type = "render";
static override schema = Type.Object({
render: Type.String(),
static override schema = s.strictObject({
render: s.string(),
});
async execute() {

View File

@@ -1,7 +1,6 @@
import { Flow } from "../../flows/Flow";
import { Task, dynamic } from "../Task";
import * as tbbox from "@sinclair/typebox";
const { Type } = tbbox;
import { s } from "bknd/utils";
export class SubFlowTask<Output extends Record<string, any>> extends Task<
typeof SubFlowTask.schema,
@@ -9,10 +8,10 @@ export class SubFlowTask<Output extends Record<string, any>> extends Task<
> {
type = "subflow";
static override schema = Type.Object({
flow: Type.Any(),
input: Type.Optional(dynamic(Type.Any(), JSON.parse)),
loop: Type.Optional(Type.Boolean()),
static override schema = s.strictObject({
flow: s.any(),
input: dynamic(s.any(), JSON.parse).optional(),
loop: s.boolean().optional(),
});
async execute() {