@feasibleone/blong-gogo 1.7.3 → 1.8.1

package/CHANGELOG.md

@@ -1,5 +1,20 @@
 # Changelog
 
+## [1.8.1](https://github.com/feasibleone/blong/compare/blong-gogo-v1.8.0...blong-gogo-v1.8.1) (2026-03-11)
+
+
+### Bug Fixes
+
+* schema generation and bin script ([df2ffa9](https://github.com/feasibleone/blong/commit/df2ffa9e1128d248f2a9c749b0559ea9fad09a26))
+
+## [1.8.0](https://github.com/feasibleone/blong/compare/blong-gogo-v1.7.3...blong-gogo-v1.8.0) (2026-03-10)
+
+
+### Features
+
+* allow config override during start, improve types ([58c3840](https://github.com/feasibleone/blong/commit/58c3840b1543ce2d963c0bbdcb1a0712feface7c))
+* support activation-based config in handler folder config.ts ([#64](https://github.com/feasibleone/blong/issues/64)) ([78e13ba](https://github.com/feasibleone/blong/commit/78e13baa0c85b05c8f31c8efa374f035e0009704))
+
 ## [1.7.3](https://github.com/feasibleone/blong/compare/blong-gogo-v1.7.2...blong-gogo-v1.7.3) (2026-03-07)
 
 

package/bin/blong-gogo.sh

@@ -9,5 +9,5 @@ else
 fi
 blong_gogo=$(npm ls -g @feasibleone/blong-gogo --parseable)
 mv -f "$blong_gogo" ./
-cp -r blong-gogo/bin/blong.sh "$blong_gogo"/bin/
+cp -r blong-gogo/bin/blong-gogo.sh "$blong_gogo"/bin/
 ./blong-gogo/bin/blong.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@feasibleone/blong-gogo",
-  "version": "1.7.3",
+  "version": "1.8.1",
   "repository": {
     "url": "git+https://github.com/feasibleone/blong.git"
   },

package/src/Gateway.ts

@@ -1,4 +1,5 @@
 import type {
+    ApiSchema,
     Errors,
     GatewaySchema,
     IErrorFactory,
@@ -68,7 +69,7 @@ interface IConfig extends IConfigMLE {
 
 function operationParams(
     operation: GatewaySchema['operation'],
-    bodySchema: TSchema,
+    bodySchema: ApiSchema,
     request: GatewayRequest,
 ): unknown {
     const result =
@@ -108,10 +109,14 @@ function operationParams(
             return result;
         }, {}) ?? {};
     if (
+        bodySchema &&
+        'type' in bodySchema &&
         bodySchema?.type === 'object' &&
-        (bodySchema.properties || bodySchema?.additionalProperties)
+        (bodySchema.properties ||
+            ('additionalProperties' in bodySchema && bodySchema?.additionalProperties))
     ) {
-        if (bodySchema.additionalProperties) Object.assign(result, request.body);
+        if ('additionalProperties' in bodySchema && bodySchema.additionalProperties)
+            Object.assign(result, request.body);
         else if (bodySchema.properties)
             Object.entries(bodySchema.properties).forEach(([name, value]) => {
                 if (name in (request.body as {})) result[snakeToCamel(name)] = request.body[name];
@@ -450,7 +455,7 @@ export default class Gateway extends Internal implements IGateway {
         });
     }
 
-    public async start(): Promise<void> {
+    public async start(): Promise<IGateway> {
         const old = this.#server;
         try {
             this.#server = fastify({
@@ -501,11 +506,13 @@ export default class Gateway extends Internal implements IGateway {
             port: this.#config.port,
             host: this.#config.host,
         });
+        return this;
     }
 
-    public async stop(): Promise<void> {
+    public async stop(): Promise<IGateway> {
         await this.#server?.close();
         this.#server = null;
+        return this;
     }
 
     protected async restart(): Promise<void> {

package/src/GatewayClient.ts

@@ -5,8 +5,8 @@ import {spare} from 'ut-function.timing';
 import Remote from './Remote.ts';
 
 export interface IGatewayClient {
-    start: () => Promise<void>;
-    stop: () => Promise<void>;
+    start: () => Promise<IGatewayClient>;
+    stop: () => Promise<IGatewayClient>;
 }
 
 interface IError extends Error {

package/src/Registry.ts

@@ -303,21 +303,23 @@ export default class Registry extends Internal implements IRegistry {
         return {local, literals};
     }
 
-    public async init(): Promise<void> {
+    public async init(): Promise<IRegistry> {
         for (const [id, {source, def}] of Object.entries(this.#config.api || {}))
             await this.loadApi(id, def, source);
+        return this;
     }
 
-    public async start(): Promise<void> {
+    public async start(configOverride?: object): Promise<IRegistry> {
         for (const id of Array.from(this.ports.keys())) await this.createPort(id);
-        for (const port of this.#ports.values()) await port.start();
+        for (const port of this.#ports.values()) await port.start(configOverride);
         for (const port of this.#ports.values()) await port.ready();
         this.#gateway?.route(await this._validations(), {name: '', version: ''});
         await this.#resolution?.start();
         await this.#rpcServer?.start();
         await this.#remote?.start();
         await this.#gateway?.start();
-        await this.#watch?.start(this, this.#remote);
+        await this.#watch?.start(this, this.#remote, configOverride);
+        return this;
         // console.dir(this.ports.entries());
         // console.dir(this.#validations);
         // console.dir(created);
@@ -337,13 +339,14 @@ export default class Registry extends Internal implements IRegistry {
         return await this.#watch.test(framework);
     }
 
-    public async stop(): Promise<void> {
+    public async stop(): Promise<IRegistry> {
         await this.#watch?.stop();
         await this.#gateway?.stop();
         await this.#remote?.stop();
         await this.#rpcServer?.stop();
         await this.#resolution?.stop();
         for (const port of this.#ports.values()) await port.stop();
+        return this;
     }
 
     public async loadApi(

package/src/Remote.ts

@@ -396,4 +396,11 @@ export default class Remote extends Internal implements IRemote {
             meta: {mtid, method, url: httpRequest?.url, language, forward, cache},
         };
     }
+
+    public async stop(): Promise<IRemote> {
+        return this;
+    }
+    public async start(): Promise<IRemote> {
+        return this;
+    }
 }

package/src/Resolution.ts

@@ -1,11 +1,11 @@
 export interface IResolution {
-    start: () => Promise<void>;
-    stop: () => Promise<void>;
+    start: () => Promise<unknown>;
+    stop: () => Promise<unknown>;
     announce: (service: string, port: number) => void;
     resolve: (
         service: string,
         invalidate: boolean,
-        namespace: string
+        namespace: string,
     ) => Promise<{
         hostname: string;
         port: string;

package/src/RpcClient.ts

@@ -212,8 +212,4 @@ export default class RpcClientImpl extends RemoteImpl implements IRpcClient {
             return stream ? [sendRequest()] : sendRequest();
         };
     }
-
-    public async stop(): Promise<void> {}
-
-    public async start(): Promise<void> {}
 }

package/src/RpcServer.ts

@@ -123,15 +123,23 @@ export default class RpcServer extends Internal implements IRpcServer {
         methods.forEach(fn => this._unregister(namespace, fn));
     }
 
-    public async start(): Promise<void> {
+    public async start(): Promise<IRpcServer> {
         this.#routes.forEach(route => this.#server.route(route));
         await this.#server.listen({
             port: this.#config.port,
             host: this.#config.host,
         });
+        return this;
     }
 
-    public async stop(): Promise<void> {
+    public async stop(): Promise<IRpcServer> {
         await this.#server.close();
+        return this;
+    }
+
+    public info(): object {
+        return {
+            address: this.#server.server.address(),
+        };
     }
 }

package/src/Watch.ts

@@ -15,12 +15,13 @@ import {readFileSync, statSync, writeFileSync} from 'fs';
 import {readdir} from 'fs/promises';
 import {EventEmitter} from 'node:events';
 import {basename, dirname, extname, join, relative, resolve} from 'path';
+import merge from 'ut-function.merge';
 
 import layerProxy from './layerProxy.ts';
 import './watch.log.ts';
 
 export interface IWatch {
-    start: (realm: IRegistry, remote: IRemote) => Promise<void>;
+    start: (realm: IRegistry, remote: IRemote, configOverride: object) => Promise<void>;
     test: (tester: unknown) => Promise<void>;
     stop: () => Promise<void>;
     load: <T extends {result: unknown}>(
@@ -34,6 +35,7 @@ export interface IWatch {
 const isCode = (filename: string): boolean => /(?<!\.d)\.m?(t|j)sx?$/i.test(filename);
 const isLayerActivation = (filename: string): boolean =>
     /^layer\.(server|browser)\.[mc]?[tj]sx?$/i.test(filename);
+const isConfig = (filename: string): boolean => /^config\.[mc]?[tj]sx?$/i.test(filename);
 const scan = async (...path: string[]): Promise<Dirent[]> =>
     (await readdir(join(...path), {withFileTypes: true})).sort((a, b) =>
         a < b ? -1 : a > b ? 1 : 0,
@@ -140,7 +142,9 @@ export default class Watch extends Internal implements IWatch {
             /* eslint-disable @rushstack/typedef-var */
 
             import {validationHandlers} from '@feasibleone/blong';
-            ${TypeScriptToTypeBox.Generate(schema.sort().join('\n')).trim()}
+            import { Type, type Static } from 'typebox';
+
+            ${TypeScriptToTypeBox.Generate(schema.sort().join('\n'), {useTypeBoxImport: false}).trim()}
 
             export default validationHandlers({
                 ${names.sort().join(',\n')}
@@ -172,10 +176,39 @@ export default class Watch extends Internal implements IWatch {
         const libs = [];
         const handlerFilenames = [];
         let latest = 0;
-        const handlerFiles = (await scan(dir))
+        const allFiles = await scan(dir);
+        const configFile = allFiles.find(entry => entry.isFile() && isConfig(entry.name));
+        if (configFile) {
+            const configFilePath = join(dir, configFile.name);
+            const loaded = (
+                await import(
+                    this.#config.enabled ? configFilePath + '?' + Date.now() : configFilePath
+                )
+            ).default;
+            const folderName = basename(dir);
+            const mutableConfig = config as Record<string, unknown>;
+            const configNames = (mutableConfig.configNames as string[]) ?? [];
+            const folderConfig =
+                loaded &&
+                typeof loaded === 'object' &&
+                typeof loaded.default === 'object' &&
+                loaded.default !== null
+                    ? merge(
+                          {},
+                          ...['default', ...configNames].map(name => loaded[name]).filter(Boolean),
+                      )
+                    : (loaded ?? {});
+            const namespaceOverride = mutableConfig?.namespace?.[folderName] ?? {};
+            mutableConfig[folderName] = merge({}, folderConfig, namespaceOverride);
+        }
+        const handlerFiles = allFiles
             .sort()
             .filter(
-                entry => entry.isFile() && isCode(entry.name) && !isLayerActivation(entry.name),
+                entry =>
+                    entry.isFile() &&
+                    isCode(entry.name) &&
+                    !isLayerActivation(entry.name) &&
+                    !isConfig(entry.name),
             );
         await this.#apiSchema.generateDir(dir, handlerFiles);
         for (const handlerEntry of handlerFiles) {
@@ -278,7 +311,7 @@ export default class Watch extends Internal implements IWatch {
         }
     }
 
-    private _watch(registry: IRegistry): void {
+    private _watch(registry: IRegistry, configOverride: object): void {
         const fsWatcher = chokidar.watch(
             Array.from(this.#handlerFolders.keys())
                 .map(folder => [
@@ -317,7 +350,7 @@ export default class Watch extends Internal implements IWatch {
                     registry.ports.set(layerConfig.name + '.' + id, item.port);
                     const port = await registry.createPort(layerConfig.name + '.' + id);
                     if (!port) return;
-                    await port.start();
+                    await port.start(configOverride);
                     await port.ready();
                     await registry.connected();
                     this.#emit.emit('test');
@@ -361,7 +394,11 @@ export default class Watch extends Internal implements IWatch {
         });
     }
 
-    public async start(registry: IRegistry, remote: IRemote): Promise<void> {
+    public async start(
+        registry: IRegistry,
+        remote: IRemote,
+        configOverride: object,
+    ): Promise<void> {
         this.log?.debug?.({
             $meta: {mtid: 'event', method: 'watch.start'},
             dir: Array.from(this.#handlerFolders.keys())
@@ -386,7 +423,7 @@ export default class Watch extends Internal implements IWatch {
                 done?.();
             });
         }
-        if (this.#config.enabled) this._watch(registry);
+        if (this.#config.enabled) this._watch(registry, configOverride);
 
         await registry.connected();
     }

package/src/codec/test/test/testCodecMle.ts

@@ -4,7 +4,7 @@ import type Assert from 'node:assert';
 const DAY = 24 * 60 * 60 * 1000;
 export default handler(
     ({lib: {group}, handler: {testLoginTokenCreate, subjectAge, subjectTime}}) => ({
-        testCodecMle: ({name = 'Message Level Encryption'}, $meta) =>
+        testCodecMle: ({name = 'Message Level Encryption'}: {name?: string}, $meta) =>
             group(name)([
                 testLoginTokenCreate({}, $meta),
                 async function mle(assert: typeof Assert, {$meta}: {$meta: IMeta}) {

package/src/codec/test/test/testLoginTokenCreate.ts

@@ -1,7 +1,7 @@
 import {handler, type IMeta} from '@feasibleone/blong';
 
 export default handler(({lib: {group}, handler: {loginTokenCreate}}) => ({
-    testLoginTokenCreate: ({name = 'login token'}) =>
+    testLoginTokenCreate: ({name = 'login token'}: {name?: string}) =>
         group(name)([
             function login(assert: unknown, {$meta}: {$meta: IMeta}) {
                 console.log('create login token');

package/src/layerProxy.ts

@@ -55,17 +55,23 @@ export default function layerProxy(
                                 );
                                 ports.forEach(what => {
                                     if (what.prototype instanceof port) {
-                                        where.port = async ({
-                                            id,
-                                            ...portApi
-                                        }: Parameters<IAdapterFactory>[0] & {id: string}) => {
+                                        where.port = async (
+                                            {
+                                                id,
+                                                ...portApi
+                                            }: Parameters<IAdapterFactory>[0] & {id: string},
+                                            configOverride: object,
+                                        ) => {
+                                            const config = {
+                                                ...moduleConfig?.[name],
+                                                id,
+                                                pkg: moduleConfig.pkg,
+                                            };
                                             const port = new (what as IPort)({
                                                 ...portApi,
-                                                config: {
-                                                    ...moduleConfig?.[name],
-                                                    id,
-                                                    pkg: moduleConfig.pkg,
-                                                },
+                                                config: configOverride
+                                                    ? merge({}, config, configOverride)
+                                                    : config,
                                                 configBase: moduleConfig.base,
                                             });
                                             await port.init();
@@ -73,10 +79,13 @@ export default function layerProxy(
                                         };
                                         where.port.config = moduleConfig?.[name];
                                     } else if (['adapter', 'orchestrator'].includes(kind(what))) {
-                                        where.port = async ({
-                                            id,
-                                            ...portApi
-                                        }: Parameters<IAdapterFactory>[0] & {id: string}) => {
+                                        where.port = async (
+                                            {
+                                                id,
+                                                ...portApi
+                                            }: Parameters<IAdapterFactory>[0] & {id: string},
+                                            configOverride: object,
+                                        ) => {
                                             if (!id) return what(portApi);
                                             const port = await createPort(
                                                 {
@@ -86,11 +95,16 @@ export default function layerProxy(
                                                 moduleConfig.base,
                                                 moduleConfig.configNames,
                                             );
-                                            await port.init({
+                                            const config = {
                                                 ...moduleConfig?.[name],
                                                 id,
                                                 pkg: moduleConfig.pkg,
-                                            });
+                                            };
+                                            await port.init(
+                                                configOverride
+                                                    ? merge({}, config, configOverride)
+                                                    : config,
+                                            );
                                             return port;
                                         };
                                         where.port.config = moduleConfig?.[name];

package/src/load.ts

@@ -7,6 +7,8 @@ import {
     type ILogger,
     type IModuleConfig,
     type IRegistry,
+    type Kind,
+    type Kinds,
     type SolutionFactory,
 } from '@feasibleone/blong';
 import {existsSync} from 'fs';
@@ -108,7 +110,7 @@ async function loadConfig(config: string | object): Promise<object> {
 }
 
 export default async function loadRealm<T extends TSchema>(
-    def: SolutionFactory<T>,
+    def: SolutionFactory<T> & {[symbol: Kind]: Kinds},
     name: string,
     parentConfig: object | string,
     configNames: string[],