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>

app/src/modules/server/AdminController.tsx

@@ -1,8 +1,9 @@
 /** @jsxImportSource hono/jsx */
 
 import type { App } from "App";
-import { config, isDebug } from "core";
-import { $console } from "core/utils";
+import { isDebug } from "core/env";
+import { config } from "core/config";
+import { $console } from "bknd/utils";
 import { addFlashMessage } from "core/server/flash";
 import { html } from "hono/html";
 import { Fragment } from "hono/jsx";

app/src/modules/server/AppServer.ts

@@ -1,37 +1,29 @@
-import { Exception, isDebug } from "core";
-import { type Static, StringEnum, $console } from "core/utils";
+import { Exception } from "core/errors";
+import { isDebug } from "core/env";
+import { $console, s } from "bknd/utils";
 import { cors } from "hono/cors";
 import { Module } from "modules/Module";
-import * as tbbox from "@sinclair/typebox";
 import { AuthException } from "auth/errors";
-const { Type } = tbbox;
 
-const serverMethods = ["GET", "POST", "PATCH", "PUT", "DELETE"];
+const serverMethods = ["GET", "POST", "PATCH", "PUT", "DELETE"] as const;
 
-export const serverConfigSchema = Type.Object(
-   {
-      cors: Type.Object(
-         {
-            origin: Type.String({ default: "*" }),
-            allow_methods: Type.Array(StringEnum(serverMethods), {
-               default: serverMethods,
-               uniqueItems: true,
-            }),
-            allow_headers: Type.Array(Type.String(), {
-               default: ["Content-Type", "Content-Length", "Authorization", "Accept"],
-            }),
-         },
-         { default: {}, additionalProperties: false },
-      ),
-   },
-   {
-      additionalProperties: false,
-   },
-);
+export const serverConfigSchema = s.strictObject({
+   cors: s.strictObject({
+      origin: s.string({ default: "*" }),
+      allow_methods: s.array(s.string({ enum: serverMethods }), {
+         default: serverMethods,
+         uniqueItems: true,
+      }),
+      allow_headers: s.array(s.string(), {
+         default: ["Content-Type", "Content-Length", "Authorization", "Accept"],
+      }),
+      allow_credentials: s.boolean({ default: true }),
+   }),
+});
 
-export type AppServerConfig = Static<typeof serverConfigSchema>;
+export type AppServerConfig = s.Static<typeof serverConfigSchema>;
 
-export class AppServer extends Module<typeof serverConfigSchema> {
+export class AppServer extends Module<AppServerConfig> {
    override getRestrictedPaths() {
       return [];
    }
@@ -45,12 +37,14 @@ export class AppServer extends Module<typeof serverConfigSchema> {
    }
 
    override async build() {
+      const origin = this.config.cors.origin ?? "";
       this.client.use(
          "*",
          cors({
-            origin: this.config.cors.origin,
+            origin: origin.includes(",") ? origin.split(",").map((o) => o.trim()) : origin,
             allowMethods: this.config.cors.allow_methods,
             allowHeaders: this.config.cors.allow_headers,
+            credentials: this.config.cors.allow_credentials,
          }),
       );
 

app/src/modules/server/SystemController.ts

@@ -2,14 +2,18 @@
 
 import type { App } from "App";
 import {
-   $console,
-   TypeInvalidError,
    datetimeStringLocal,
    datetimeStringUTC,
    getTimezone,
    getTimezoneOffset,
-} from "core/utils";
-import { getRuntimeKey } from "core/utils";
+   $console,
+   getRuntimeKey,
+   SecretSchema,
+   jsc,
+   s,
+   describeRoute,
+   InvalidSchemaError,
+} from "bknd/utils";
 import type { Context, Hono } from "hono";
 import { Controller } from "modules/Controller";
 import { openAPISpecs } from "jsonv-ts/hono";
@@ -19,11 +23,10 @@ import {
    type ModuleConfigs,
    type ModuleSchemas,
    type ModuleKey,
-   getDefaultConfig,
 } from "modules/ModuleManager";
 import * as SystemPermissions from "modules/permissions";
-import { jsc, s, describeRoute } from "core/object/schema";
 import { getVersion } from "core/env";
+
 export type ConfigUpdate<Key extends ModuleKey = ModuleKey> = {
    success: true;
    module: Key;
@@ -103,7 +106,7 @@ export class SystemController extends Controller {
          } catch (e) {
             $console.error("config update error", e);
 
-            if (e instanceof TypeInvalidError) {
+            if (e instanceof InvalidSchemaError) {
                return c.json(
                   { success: false, type: "type-invalid", errors: e.errors },
                   { status: 400 },
@@ -233,11 +236,13 @@ export class SystemController extends Controller {
          permission(SystemPermissions.schemaRead),
          jsc(
             "query",
-            s.partialObject({
-               config: s.boolean(),
-               secrets: s.boolean(),
-               fresh: s.boolean(),
-            }),
+            s
+               .object({
+                  config: s.boolean(),
+                  secrets: s.boolean(),
+                  fresh: s.boolean(),
+               })
+               .partial(),
          ),
          async (c) => {
             const module = c.req.param("module") as ModuleKey | undefined;
@@ -321,7 +326,21 @@ export class SystemController extends Controller {
                   local: datetimeStringLocal(),
                   utc: datetimeStringUTC(),
                },
+               origin: new URL(c.req.raw.url).origin,
                plugins: Array.from(this.app.plugins.keys()),
+               walk: {
+                  auth: [
+                     ...c
+                        .get("app")
+                        .getSchema()
+                        .auth.walk({ data: c.get("app").toJSON(true).auth }),
+                  ]
+                     .filter((n) => n.schema instanceof SecretSchema)
+                     .map((n) => ({
+                        ...n,
+                        schema: n.schema.constructor.name,
+                     })),
+               },
             }),
       );
 

app/src/modules/server/openapi.ts

@@ -1,313 +0,0 @@
-import type { ModuleConfigs } from "modules/ModuleManager";
-import type { OpenAPIV3 as OAS } from "openapi-types";
-import * as tbbox from "@sinclair/typebox";
-const { Type } = tbbox;
-
-function prefixPaths(paths: OAS.PathsObject, prefix: string): OAS.PathsObject {
-   const result: OAS.PathsObject = {};
-   for (const [path, pathItem] of Object.entries(paths)) {
-      result[`${prefix}${path}`] = pathItem;
-   }
-   return result;
-}
-
-function systemRoutes(config: ModuleConfigs): { paths: OAS.Document["paths"] } {
-   const tags = ["system"];
-   const paths: OAS.PathsObject = {
-      "/ping": {
-         get: {
-            summary: "Ping",
-            responses: {
-               "200": {
-                  description: "Pong",
-                  content: {
-                     "application/json": {
-                        schema: Type.Object({
-                           pong: Type.Boolean({ default: true }),
-                        }),
-                     },
-                  },
-               },
-            },
-            tags,
-         },
-      },
-      "/config": {
-         get: {
-            summary: "Get config",
-            responses: {
-               "200": {
-                  description: "Config",
-                  content: {
-                     "application/json": {
-                        schema: Type.Object({
-                           version: Type.Number() as any,
-                           server: Type.Object({}),
-                           data: Type.Object({}),
-                           auth: Type.Object({}),
-                           flows: Type.Object({}),
-                           media: Type.Object({}),
-                        }),
-                     },
-                  },
-               },
-            },
-            tags,
-         },
-      },
-      "/schema": {
-         get: {
-            summary: "Get config",
-            responses: {
-               "200": {
-                  description: "Config",
-                  content: {
-                     "application/json": {
-                        schema: Type.Object({
-                           version: Type.Number() as any,
-                           schema: Type.Object({
-                              server: Type.Object({}),
-                              data: Type.Object({}),
-                              auth: Type.Object({}),
-                              flows: Type.Object({}),
-                              media: Type.Object({}),
-                           }),
-                        }),
-                     },
-                  },
-               },
-            },
-            tags,
-         },
-      },
-   };
-
-   return { paths: prefixPaths(paths, "/api/system") };
-}
-
-function dataRoutes(config: ModuleConfigs): { paths: OAS.Document["paths"] } {
-   const schemas = {
-      entityData: Type.Object({
-         id: Type.Number() as any,
-      }),
-   };
-   const repoManyResponses: OAS.ResponsesObject = {
-      "200": {
-         description: "List of entities",
-         content: {
-            "application/json": {
-               schema: Type.Array(schemas.entityData),
-            },
-         },
-      },
-   };
-   const repoSingleResponses: OAS.ResponsesObject = {
-      "200": {
-         description: "Entity",
-         content: {
-            "application/json": {
-               schema: schemas.entityData,
-            },
-         },
-      },
-   };
-   const params = {
-      entity: {
-         name: "entity",
-         in: "path",
-         required: true,
-         schema: Type.String(),
-      },
-      entityId: {
-         name: "id",
-         in: "path",
-         required: true,
-         schema: Type.Number() as any,
-      },
-   };
-
-   const tags = ["data"];
-   const paths: OAS.PathsObject = {
-      "/entity/{entity}": {
-         get: {
-            summary: "List entities",
-            parameters: [params.entity],
-            responses: repoManyResponses,
-            tags,
-         },
-         post: {
-            summary: "Create entity",
-            parameters: [params.entity],
-            requestBody: {
-               content: {
-                  "application/json": {
-                     schema: Type.Object({}),
-                  },
-               },
-            },
-            responses: repoSingleResponses,
-            tags,
-         },
-      },
-      "/entity/{entity}/{id}": {
-         get: {
-            summary: "Get entity",
-            parameters: [params.entity, params.entityId],
-            responses: repoSingleResponses,
-            tags,
-         },
-         patch: {
-            summary: "Update entity",
-            parameters: [params.entity, params.entityId],
-            requestBody: {
-               content: {
-                  "application/json": {
-                     schema: Type.Object({}),
-                  },
-               },
-            },
-            responses: repoSingleResponses,
-            tags,
-         },
-         delete: {
-            summary: "Delete entity",
-            parameters: [params.entity, params.entityId],
-            responses: {
-               "200": {
-                  description: "Entity deleted",
-               },
-            },
-            tags,
-         },
-      },
-   };
-
-   return { paths: prefixPaths(paths, config.data.basepath!) };
-}
-
-function authRoutes(config: ModuleConfigs): { paths: OAS.Document["paths"] } {
-   const schemas = {
-      user: Type.Object({
-         id: Type.String(),
-         email: Type.String(),
-         name: Type.String(),
-      }),
-   };
-
-   const tags = ["auth"];
-   const paths: OAS.PathsObject = {
-      "/password/login": {
-         post: {
-            summary: "Login",
-            requestBody: {
-               content: {
-                  "application/json": {
-                     schema: Type.Object({
-                        email: Type.String(),
-                        password: Type.String(),
-                     }),
-                  },
-               },
-            },
-            responses: {
-               "200": {
-                  description: "User",
-                  content: {
-                     "application/json": {
-                        schema: Type.Object({
-                           user: schemas.user,
-                        }),
-                     },
-                  },
-               },
-            },
-            tags,
-         },
-      },
-      "/password/register": {
-         post: {
-            summary: "Register",
-            requestBody: {
-               content: {
-                  "application/json": {
-                     schema: Type.Object({
-                        email: Type.String(),
-                        password: Type.String(),
-                     }),
-                  },
-               },
-            },
-            responses: {
-               "200": {
-                  description: "User",
-                  content: {
-                     "application/json": {
-                        schema: Type.Object({
-                           user: schemas.user,
-                        }),
-                     },
-                  },
-               },
-            },
-            tags,
-         },
-      },
-      "/me": {
-         get: {
-            summary: "Get me",
-            responses: {
-               "200": {
-                  description: "User",
-                  content: {
-                     "application/json": {
-                        schema: Type.Object({
-                           user: schemas.user,
-                        }),
-                     },
-                  },
-               },
-            },
-            tags,
-         },
-      },
-      "/strategies": {
-         get: {
-            summary: "Get auth strategies",
-            responses: {
-               "200": {
-                  description: "Strategies",
-                  content: {
-                     "application/json": {
-                        schema: Type.Object({
-                           strategies: Type.Object({}),
-                        }),
-                     },
-                  },
-               },
-            },
-            tags,
-         },
-      },
-   };
-
-   return { paths: prefixPaths(paths, config.auth.basepath!) };
-}
-
-export function generateOpenAPI(config: ModuleConfigs): OAS.Document {
-   const system = systemRoutes(config);
-   const data = dataRoutes(config);
-   const auth = authRoutes(config);
-
-   return {
-      openapi: "3.1.0",
-      info: {
-         title: "bknd API",
-         version: "0.0.0",
-      },
-      paths: {
-         ...system.paths,
-         ...data.paths,
-         ...auth.paths,
-      },
-   };
-}