@feasibleone/blong 1.22.0 → 1.24.0

package/CHANGELOG.md

@@ -1,5 +1,39 @@
 # Changelog
 
+## [1.24.0](https://github.com/feasibleone/blong/compare/blong-v1.23.0...blong-v1.24.0) (2026-08-19)
+
+
+### Features
+
+* master-detail handling ([03c5bbd](https://github.com/feasibleone/blong/commit/03c5bbd9401a82a9427577e7611f2622aadee4e5))
+* redis adapter and blong-gateway ([c28a68f](https://github.com/feasibleone/blong/commit/c28a68f5f9cfc2398771cca05c4366efc147eb6e))
+* resolve some AI agent frictions ([13ca27f](https://github.com/feasibleone/blong/commit/13ca27f09f0271a25ea7ad45a2ce3f73bf6710e0))
+* resolve some AI agent frictions and improve the framework features ([23b6986](https://github.com/feasibleone/blong/commit/23b69863b458e97f1dad249fcdeec5e182a69b74))
+
+## [1.23.0](https://github.com/feasibleone/blong/compare/blong-v1.22.0...blong-v1.23.0) (2026-07-14)
+
+
+### Features
+
+* blong-mock, blong-server ([756caca](https://github.com/feasibleone/blong/commit/756cacab712db6792bf1b93830fc1d833b396f8d))
+* check access credentials ([e6af405](https://github.com/feasibleone/blong/commit/e6af405c43921cb9c553db9c4986b7fe56154724))
+* core.resource merging ([371d3e2](https://github.com/feasibleone/blong/commit/371d3e2b3f519dfd59ca4fd480bc33317992afcd))
+* implement subjectObjectSchema ([8ca3282](https://github.com/feasibleone/blong/commit/8ca32829277b9816eb5e43ce708d2f1d0cc3ef28))
+* manifest concept ([ed3c038](https://github.com/feasibleone/blong/commit/ed3c038352644d2d8f828b3cb69cbea718e7084b))
+* object schema ([688d5d2](https://github.com/feasibleone/blong/commit/688d5d2a4a895c8feba7b898da03c46b3a3f3292))
+* schema helpers and constraints ([8409257](https://github.com/feasibleone/blong/commit/84092571f6b327c1166ef142f70cb7d91b013eaf))
+* seed ([5c76603](https://github.com/feasibleone/blong/commit/5c7660392bc1197638810e864bfd47ce1218b2e5))
+* support expressions in the configuration ([843bb58](https://github.com/feasibleone/blong/commit/843bb58c97456d85eac573874c90755bdb68bc95))
+* useBlong ([affdd67](https://github.com/feasibleone/blong/commit/affdd676db3338266d60155604e3bc9024078b5e))
+
+
+### Bug Fixes
+
+* build ([de22713](https://github.com/feasibleone/blong/commit/de2271393350945b8d793ca0ec89670465bba085))
+* core.resource merging ([f191055](https://github.com/feasibleone/blong/commit/f1910558ce0f369f556911c4c0f6397b8003fd33))
+* full stack alignment for CRUD ([8795e08](https://github.com/feasibleone/blong/commit/8795e087182402ac28c3ea03c6bee27319069625))
+* Playwright, Storybook and realm DRY ([4302512](https://github.com/feasibleone/blong/commit/43025123e613ef43e0ac5b83ab00fbc0cabfccf2))
+
 ## [1.22.0](https://github.com/feasibleone/blong/compare/blong-v1.21.0...blong-v1.22.0) (2026-05-25)
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@feasibleone/blong",
-  "version": "1.22.0",
+  "version": "1.24.0",
   "description": "API and DRY focused RAD framework https://feasibleone.github.io/blong-docs",
   "keywords": [
     "blong",
@@ -40,14 +40,14 @@
     "bson": "^7.2.0",
     "chokidar": "^5.0.0",
     "dts-bundle-generator": "^9.5.1",
-    "knex": "^3.1.0",
+    "knex": "^3.2.10",
     "mongodb": "^7.1.0",
     "node-vault": "^0.10.10",
     "openapi-types": "^12.1.3",
     "react": "^19.1.0",
     "tarn": "^3.0.2",
     "typescript": "^6.0.3",
-    "@feasibleone/blong-dev": "1.0.2"
+    "@feasibleone/blong-dev": "1.2.0"
   },
   "scripts": {
     "build": "heft build --clean;dts-bundle-generator --config dts-gen.config.json",

package/types.ts

@@ -19,9 +19,12 @@ import {
     type TIntersect,
     type TNever,
     type TNumber,
+    type TNumberOptions,
     type TObject,
     type TSchema,
+    type TSchemaOptions,
     type TString,
+    type TStringOptions,
     type TUnknown,
 } from 'typebox';
 // import type {client} from 'node-vault';
@@ -65,6 +68,12 @@ export type ServerContext = {
     // s3?: S3Client;
     slack?: IncomingWebhook;
     // vault?: client;
+    /** Live redis client shared with derived adapters. */
+    redis?: {
+        status: string;
+        connect(): Promise<unknown>;
+        quit(): Promise<unknown>;
+    };
 };
 
 export type BrowserContext = {
@@ -132,11 +141,38 @@ export interface IWatcher extends EventEmitter<FSWatcherEventMap> {
 
 export type HRTime = [number, number];
 
+type BaseConfig = {
+    name: string;
+    pkg: {name: string; version: string};
+    children: unknown[];
+    url: string;
+    base: string;
+    server: {
+        load: {logLevel: Parameters<ILog['logger']>[0]};
+        realm: {logLevel: Parameters<ILog['logger']>[0]};
+    };
+    browser: {
+        load: {logLevel: Parameters<ILog['logger']>[0]};
+        realm: {logLevel: Parameters<ILog['logger']>[0]};
+    };
+    kopi?: {realm?: unknown};
+    watch?: {configs?: object};
+    configs?: object;
+    configNames: string[];
+};
+
 export interface IPlatformApi {
     platform: 'server' | 'browser';
     loadConfig: (
-        config: string | object,
-    ) => Promise<{loadedConfig?: object; configRuntime?: IConfigRuntime}>;
+        baseConfig: BaseConfig,
+        parentConfig: string | object,
+        loadedConfigs: object[],
+    ) => Promise<{
+        loadedConfig: BaseConfig & {
+            [key: string]: unknown;
+        };
+        configRuntime?: IConfigRuntime;
+    }>;
     readdir: (path: string) => Promise<Dirent[]>;
     scan: (...path: string[]) => Promise<Dirent[]>;
     existsSync: (path: string) => boolean;
@@ -163,6 +199,7 @@ export interface IPlatformApi {
         spare: (time: HRTime, latency?: number) => number;
     };
     configs: string[];
+    context: Record<string, unknown>;
 }
 
 export interface IErrorFactory {
@@ -263,6 +300,12 @@ export interface IApiSchema {
     ): unknown;
 }
 
+export interface IObjectSchema {
+    [subject: string]: {
+        [object: string]: TObject;
+    };
+}
+
 export interface IGateway {
     route: (
         validations: Record<string, GatewaySchema>,
@@ -291,6 +334,7 @@ export interface IRegistry {
     ports: Map<string, IAdapterRegistry>;
     methods: Map<string, Handlers>;
     modules: Map<string | symbol, IRegistry[]>;
+    objectSchema: IObjectSchema;
     createPort: (id: string) => Promise<Adapter | undefined>;
     getPort: (id: string) => Adapter | undefined;
     replaceHandlers: (id: string, handlers: Handlers) => Promise<void>;
@@ -304,9 +348,31 @@ export interface IRegistry {
     connected: () => Promise<boolean>;
 }
 
+type BlongType = typeof Type & {
+    increment: () => TSchema;
+    integerNull: (options?: TNumberOptions) => TSchema;
+    integerNotNull: (options?: TNumberOptions) => TSchema;
+    bigIntNull: (options?: TNumberOptions) => TSchema;
+    bigIntNotNull: (options?: TNumberOptions) => TSchema;
+    stringNull: (options?: TStringOptions) => TSchema;
+    stringNotNull: (options?: TStringOptions) => TSchema;
+    numberNull: (options?: TNumberOptions) => TSchema;
+    numberNotNull: (options?: TNumberOptions) => TSchema;
+    booleanNull: (options?: TSchemaOptions) => TSchema;
+    booleanNotNull: (options?: TSchemaOptions) => TSchema;
+    dateNull: () => TSchema;
+    dateNotNull: () => TSchema;
+    dateTimeNull: () => TSchema;
+    dateTimeNotNull: () => TSchema;
+    ulid: () => TSchema;
+    uuid: () => TSchema;
+    uidNull: () => TSchema;
+    uidNotNull: () => TSchema;
+};
+
 export interface IApi {
     id?: string;
-    type: typeof Type;
+    type: BlongType;
     adapter: (id: string) => IAdapterRegistry | undefined;
     utError: IError;
     errors: IErrorFactory;
@@ -315,6 +381,7 @@ export interface IApi {
     rpc: IRpcServer;
     local: ILocal;
     registry: IRegistry;
+    schema: IObjectSchema;
     register: (
         methods:
             | Record<string, (...params: unknown[]) => Promise<unknown>>
@@ -349,9 +416,16 @@ export interface IApi {
         patterns: (string | RegExp)[] | string | RegExp,
         adapter?: boolean,
     ) => unknown;
+    attach: (target: object, patterns: (string | RegExp)[] | string | RegExp) => Promise<object>;
     createLog: ILog['logger'];
     attachCheckpoint?: (meta: IMeta) => void;
-    handlers?: (api: {utError: IError; remote: IRemote; type: typeof Type}) => {
+    handlers?: (api: {
+        utError: IError;
+        remote: IRemote;
+        type: BlongType;
+        schema: IObjectSchema;
+        manifest?: IManifest;
+    }) => {
         extends?:
             | string
             | ((api: {
@@ -360,8 +434,13 @@ export interface IApi {
                   rpc: IRpcServer;
                   local: ILocal;
                   registry: IRegistry;
+                  schema: IObjectSchema;
+                  manifest?: IManifest;
               }) => object);
     };
+    render: (what: object[] | object) => object;
+    platform: IPlatformApi;
+    manifest?: IManifest;
 }
 
 export interface IErrorMap {
@@ -388,6 +467,7 @@ export type Adapter<T = Record<string, unknown>, C = Record<string, unknown>> =
         | 'findValidation'
         | 'getConversion'
         | 'dispatch'
+        | 'platform'
     >;
 export interface IAdapter<T, C> {
     validation?: TSchema;
@@ -399,20 +479,17 @@ export interface IAdapter<T, C> {
     imported?: Record<string, PortHandlerBound>;
     importedMap?: Map<string, IRemoteHandler>;
     extends?: object | `adapter.${string}` | `orchestrator.${string}`;
+    platform?: IPlatformApi;
     activeConfig?(this: Adapter<T, C>): Partial<Config<T, C>>;
     init?(this: Adapter<T, C>, ...config: unknown[]): Promise<unknown>;
     start?(this: Adapter<T, C>, ...params: unknown[]): Promise<unknown>;
     ready?(this: Adapter<T, C>): Promise<unknown>;
     stop?(this: Adapter<T, C>, ...params: unknown[]): Promise<unknown>;
-    link?(
+    attach?<R extends object>(
         this: Adapter<T, C>,
         patterns: (string | RegExp)[] | string | RegExp,
-        target: object,
-    ): Promise<{
-        importedMap?: Map<string, object>;
-        imported?: object;
-        config?: {namespace?: string | string[]};
-    }>;
+        target?: R,
+    ): Promise<R>;
     connected?(this: Adapter<T, C>): Promise<boolean>;
     error?(error: unknown, $meta: unknown): void;
     pack?(this: Adapter<T, C>, ...params: unknown[]): unknown;
@@ -487,6 +564,8 @@ export interface IAdapterRegistry {
         rpc: IRpcServer;
         local: ILocal;
         registry: IRegistry;
+        schema: IObjectSchema;
+        manifest?: IManifest;
     }): Promise<Adapter>;
 }
 
@@ -605,18 +684,28 @@ export type Errors<T> = {
 
 export interface IBaseConfig extends TObject<{
     watch: TObject<{
-        test: TArray<TString>;
+        test?: TArray<TString>;
     }>;
     remote: TObject<{
-        canSkipSocket: TBoolean;
+        canSkipSocket?: TBoolean;
     }>;
-    adapter: TBoolean;
-    orchestrator: TBoolean;
-    test: TBoolean;
-    error: TBoolean;
+    adapter: TBoolean | TObject;
+    orchestrator: TBoolean | TObject;
+    test: TBoolean | TObject;
+    error: TBoolean | TObject;
     gateway: TBoolean | TObject;
-    sim: TBoolean;
-    resolution: TBoolean;
+    sim: TBoolean | TObject;
+    resolution: TBoolean | TObject;
+    log: TBoolean | TObject;
+    apiSchema: TBoolean | TObject;
+    registry: TBoolean | TObject;
+    port: TBoolean | TObject;
+    codec: TBoolean | TObject;
+    local: TBoolean | TObject;
+    rpcServer: TBoolean | TObject;
+    restFs: TBoolean | TObject;
+    systemDebug: TBoolean | TObject;
+    apiGateway: TBoolean | TObject;
 }> {
     additionalProperties: false;
 }
@@ -650,6 +739,27 @@ export interface ILogger {
     warn?: LogFn;
     error?: LogFn;
     fatal?: LogFn;
+    /**
+     * Wrap a long-running promise and report progress on this logger.
+     *
+     * Once the operation runs past `thresholdMs`, a snapshot (from `getProgress`)
+     * is logged every `intervalMs` at the given `level` (default 'warn'), followed
+     * by a completion line. Delegates to the shared `withProgress` helper from
+     * `@feasibleone/blong-lib`.
+     *
+     * @example
+     * await runtime.log.progress('schema sync', syncPromise, {getProgress: () => ({done: 1, total: 2})});
+     */
+    progress?: <T>(
+        label: string,
+        promise: Promise<T>,
+        options?: {
+            getProgress?: () => string | object;
+            thresholdMs?: number;
+            intervalMs?: number;
+            level?: 'info' | 'warn';
+        },
+    ) => Promise<T>;
 }
 
 export interface IStep {
@@ -692,6 +802,10 @@ export type GatewaySchema = (
     subject?: string;
     destination?: string;
     operation?: OpenAPIV3_1.OperationObject | OpenAPIV2.OperationObject;
+    /** Metering metadata threaded into the Fastify route config by Gateway.ts. */
+    bundle?: string;
+    creditCost?: number;
+    meter?: boolean;
 };
 
 export type SchemaObject = OpenAPIV3_1.SchemaObject | OpenAPIV2.SchemaObject;
@@ -725,8 +839,25 @@ export type ChainStep =
 
 export type CheckpointFn = (this: IMeta, name: string, data?: unknown) => void;
 
+/**
+ * Manifest — a shared mutable object passed to the `load` function that allows
+ * platforms to share information such as effective ports, URLs, or other
+ * runtime-resolved values across components.
+ *
+ * Properties are typically Promises (created via `Promise.withResolvers()`) that
+ * are resolved when one platform finishes a startup step (e.g. listening on a
+ * random port), and awaited by another platform or adapter during its own
+ * initialisation (e.g. constructing a backend URL from the effective port).
+ *
+ * Manifest properties can also be provided via CLI args using the
+ * `--manifest.<key>=<value>` syntax.
+ */
+export interface IManifest {
+    [key: string]: unknown;
+}
+
 export interface ILib {
-    type: typeof Type;
+    type: BlongType;
     error: <T>(errors: T) => Record<keyof T, (params?: unknown, $meta?: IMeta) => ITypedError>;
     rename: <T extends object>(object: T, name: string) => T & {name: string};
     /**
@@ -773,26 +904,44 @@ export interface ILib {
     merge<T, S1, S2>(target: T, source1: S1, source2: S2): T & S1 & S2;
     merge<T, S1, S2, S3>(target: T, source1: S1, source2: S2, source3: S3): T & S1 & S2 & S3;
     merge<T>(...args: unknown[]): T;
+    mergeWithSymbols<T, S1>(target: T, source: S1): T & S1;
+    render: (what: object[] | object) => object;
+    crockfordEncode: (data: Uint8Array) => string;
+    crockfordDecode: (data: string) => Uint8Array;
+    withProgress: <T>(
+        log: {info?: LogFn; warn?: LogFn} | undefined,
+        label: string,
+        promise: Promise<T>,
+        options?: {
+            getProgress?: () => string | object;
+            thresholdMs?: number;
+            intervalMs?: number;
+            level?: 'info' | 'warn';
+        },
+    ) => Promise<T>;
 }
 
 export type ValidationFn = () => GatewaySchema;
-export interface IValidationProxy {
+export interface IValidationProxy<T> {
     type: typeof Type;
     handler: {
         [name: string]: ValidationFn;
-    };
+    } & IRemoteHandler;
     lib: ILib & {
         [name: string]: TSchema;
     };
     error: {
         [name: string]: (...params: unknown[]) => ITypedError;
     };
+    /** Collected object schemas accumulated so far; later `schema()` exports can reference earlier ones. */
+    schema: IObjectSchema;
+    config: T;
 }
-export type ValidationDefinition = (
-    blong: IValidationProxy,
-) => Record<string, ValidationFn | TSchema> | ValidationFn | ValidationFn[];
+export type ValidationDefinition<T> = (
+    blong: IValidationProxy<T>,
+) => Promise<Record<string, ValidationFn | TSchema> | ValidationFn | ValidationFn[]>;
 
-export type ApiDefinition = (blong: IValidationProxy) =>
+export type ApiDefinition<T> = (blong: IValidationProxy<T>) =>
     | {
           namespace:
               | string[]
@@ -838,6 +987,8 @@ export interface IHandlerProxy<T> {
     errors: {
         [name: string]: (...params: unknown[]) => ITypedError;
     };
+    /** Collected object schemas from all registered `schema()` exports. */
+    schema: IObjectSchema;
     utBus: {
         info: () => {encrypt: object; sign: object};
     };
@@ -859,8 +1010,8 @@ export type ModuleApi = {
     config: Record<string, unknown>;
     parent: IAdapterFactory;
     error: (errors: object) => ModuleApi;
-    validation: (
-        method: ValidationDefinition | ValidationDefinition[],
+    validation: <T>(
+        method: ValidationDefinition<T> | ValidationDefinition<T>[],
         namespace?: string,
     ) => ModuleApi;
     sequence: (fn: () => Sequence) => ModuleApi;
@@ -873,7 +1024,10 @@ export type ModuleApi = {
 };
 
 export interface SolutionFactory<T extends TSchema = TNever> {
-    (definition: {type: typeof Type}): IModuleConfig<T> | Promise<IModuleConfig<T>>;
+    (definition: {
+        type: typeof Type;
+        manifest?: IManifest;
+    }): IModuleConfig<T> | Promise<IModuleConfig<T>>;
 }
 
 const Kind: symbol = Symbol.for('blong:kind');
@@ -921,9 +1075,13 @@ export interface IComponent {
 
 export const library = <T = Record<string, unknown>>(definition: Lib<T>): Lib<T> =>
     Object.defineProperty(definition, Kind, {value: 'lib'});
-export const validation = (validation: ValidationDefinition): ValidationDefinition =>
-    Object.defineProperty(validation, Kind, {value: 'validation'});
-export const api = (api: ApiDefinition): ApiDefinition =>
+export const validation = <T = Record<string, unknown>>(
+    validation: ValidationDefinition<T>,
+): ValidationDefinition<T> => Object.defineProperty(validation, Kind, {value: 'validation'});
+export const schema = <T = Record<string, unknown>>(
+    schema: ValidationDefinition<T>,
+): ValidationDefinition<T> => Object.defineProperty(schema, Kind, {value: 'schema'});
+export const api = <T = Record<string, unknown>>(api: ApiDefinition<T>): ApiDefinition<T> =>
     Object.defineProperty(api, Kind, {value: 'api'});
 export const model = <T extends IModelSpec>(
     definition: () => () => Promise<T>,
@@ -931,10 +1089,10 @@ export const model = <T extends IModelSpec>(
 export const fixture = <T extends IMock>(definition: () => T): (() => T) =>
     Object.defineProperty(definition, Kind, {value: 'fixture'});
 
-export const validationHandlers: (
+export const validationHandlers: <T>(
     handlers: Record<string, TFunction<[ApiSchema]>>,
-) => ValidationDefinition = handlers =>
-    validation(() =>
+) => ValidationDefinition<T> = handlers =>
+    validation(async () =>
         Object.fromEntries(
             Object.entries(handlers).map(([name, handler]) => [
                 name,
@@ -989,6 +1147,7 @@ export const orchestrator = <T, C = AdapterContext>(
 export type Kinds =
     | 'lib'
     | 'validation'
+    | 'schema'
     | 'api'
     | 'solution'
     | 'server'

package/dist/knex.js

@@ -1,7 +0,0 @@
-// Bundled Knex TypeScript Declaration File
-// Generated from: https://github.com/knex/knex/blob/master/types/index.d.ts
-// All transitive dependencies have been replaced with suitable alternatives or unknown types
-// TypeScript Version: 4.1+
-export default knex;
-export { Knex };
-//# sourceMappingURL=knex.js.map

package/dist/knex.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"knex.js","sourceRoot":"","sources":["../knex.ts"],"names":[],"mappings":"AAAA,2CAA2C;AAC3C,4EAA4E;AAC5E,6FAA6F;AAC7F,2BAA2B;AAy/F3B,eAAe,IAAI,CAAC;AACpB,OAAO,EAAC,IAAI,EAAC,CAAC"}

package/dist/model.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=model.js.map

package/dist/model.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"model.js","sourceRoot":"","sources":["../model.ts"],"names":[],"mappings":""}