lambder 2.0.2 → 2.0.4

package/dist/Lambder.d.ts

@@ -115,7 +115,7 @@ export default class Lambder<TSessionData = any, _TContract extends Record<strin
     private handleNoMatchedAction;
     addRoute(condition: Path | ConditionFunction | RegExp, actionFn: ActionFunction): this;
     addSessionRoute(condition: Path | ConditionFunction | RegExp, actionFn: SessionActionFunction<TSessionData>): this;
-    use<_TNewContract extends Record<string, any>>(plugin: (lambder: Lambder<TSessionData, _TContract>) => Lambder<TSessionData, _TNewContract>): Lambder<TSessionData, _TNewContract>;
+    use<_TNewContract extends Record<string, any>>(plugin: (lambder: Lambder<TSessionData, _TContract>) => Lambder<TSessionData, _TNewContract>): Lambder<TSessionData, _TNewContract extends _TContract ? _TNewContract : (_TContract & _TNewContract)>;
     addApi<TName extends string, TInput extends z.ZodTypeAny, TOutput extends z.ZodTypeAny>(name: TName, schema: {
         input: TInput;
         output: TOutput;
@@ -124,10 +124,10 @@ export default class Lambder<TSessionData = any, _TContract extends Record<strin
         input: TInput;
         output: TOutput;
     }, handler: (ctx: LambderSessionRenderContext<z.infer<TInput>, TSessionData>, resolver: LambderResolver<z.infer<TOutput>>) => LambderResolverResponse | Promise<LambderResolverResponse>): Lambder<TSessionData, MergeContract<_TContract, TName, z.infer<TInput>, z.infer<TOutput>>>;
-    addHook(hookEvent: 'created', hookFn: HookCreatedFunction, priority?: number): Promise<void>;
-    addHook(hookEvent: 'beforeRender', hookFn: HookBeforeRenderFunction, priority?: number): Promise<void>;
-    addHook(hookEvent: 'afterRender', hookFn: HookAfterRenderFunction, priority?: number): Promise<void>;
-    addHook(hookEvent: 'fallback', hookFn: HookFallbackFunction, priority?: number): Promise<void>;
+    addHook(hookEvent: 'created', hookFn: HookCreatedFunction, priority?: number): Promise<this>;
+    addHook(hookEvent: 'beforeRender', hookFn: HookBeforeRenderFunction, priority?: number): this;
+    addHook(hookEvent: 'afterRender', hookFn: HookAfterRenderFunction, priority?: number): this;
+    addHook(hookEvent: 'fallback', hookFn: HookFallbackFunction, priority?: number): this;
     getSessionController(ctx: LambderRenderContext<any> | LambderSessionRenderContext<any, TSessionData>): LambderSessionController<TSessionData>;
     getResponseBuilder(): LambderResponseBuilder<any>;
     private getResolver;

package/dist/Lambder.js

@@ -250,13 +250,14 @@ export default class Lambder {
         });
         return this;
     }
-    async addHook(hookEvent, hookFn, priority = 0) {
+    addHook(hookEvent, hookFn, priority = 0) {
         if (hookEvent === "created") {
-            await hookFn(this);
+            return hookFn(this).then(() => this);
         }
         else {
             this.hookList[hookEvent].push({ priority, hookFn });
             this.hookList[hookEvent].sort((a, b) => a.priority - b.priority);
+            return this;
         }
     }
     getSessionController(ctx) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lambder",
-  "version": "2.0.2",
+  "version": "2.0.4",
   "description": "",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/Lambder.ts

@@ -285,8 +285,8 @@ export default class Lambder<TSessionData = any, _TContract extends Record<strin
     // Plugin system
     public use<_TNewContract extends Record<string, any>>(
         plugin: (lambder: Lambder<TSessionData, _TContract>) => Lambder<TSessionData, _TNewContract>
-    ): Lambder<TSessionData, _TNewContract> {
-        return plugin(this);
+    ): Lambder<TSessionData, _TNewContract extends _TContract ? _TNewContract : (_TContract & _TNewContract)> {
+        return plugin(this) as any;
     }
 
     // Typed API with Zod
@@ -361,20 +361,21 @@ export default class Lambder<TSessionData = any, _TContract extends Record<strin
         return this as any;
     }
 
-    async addHook(hookEvent: 'created', hookFn: HookCreatedFunction, priority?: number): Promise<void>;
-    async addHook(hookEvent: 'beforeRender', hookFn: HookBeforeRenderFunction, priority?: number): Promise<void>;
-    async addHook(hookEvent: 'afterRender', hookFn: HookAfterRenderFunction, priority?: number): Promise<void>;
-    async addHook(hookEvent: 'fallback', hookFn: HookFallbackFunction, priority?: number): Promise<void>;
-    async addHook(
+    addHook(hookEvent: 'created', hookFn: HookCreatedFunction, priority?: number): Promise<this>;
+    addHook(hookEvent: 'beforeRender', hookFn: HookBeforeRenderFunction, priority?: number): this;
+    addHook(hookEvent: 'afterRender', hookFn: HookAfterRenderFunction, priority?: number): this;
+    addHook(hookEvent: 'fallback', hookFn: HookFallbackFunction, priority?: number): this;
+    addHook(
         hookEvent:HookEventType, 
         hookFn: HookCreatedFunction & HookBeforeRenderFunction & HookAfterRenderFunction & HookFallbackFunction,
         priority = 0
-    ): Promise<void> {
+    ): this | Promise<this> {
         if(hookEvent === "created"){
-            await hookFn(this);
+            return hookFn(this).then(() => this);
         }else{
             this.hookList[hookEvent].push({ priority, hookFn });
             this.hookList[hookEvent].sort((a, b) => a.priority - b.priority);
+            return this;
         }
     }
 

package/tests/use-plugin.test.ts

@@ -4,7 +4,7 @@
  * This file tests the plugin system that allows modular API composition
  */
 
-import { describe, it, expect } from 'vitest';
+import { describe, it, expect, expectTypeOf } from 'vitest';
 import { z } from 'zod';
 import Lambder from '../src/Lambder.js';
 import LambderCaller from '../src/LambderCaller.js';
@@ -435,3 +435,24 @@ describe('Plugin System - Type Safety', () => {
         expect(caller).toBeDefined();
     });
 });
+
+// ============================================================================
+// Test 7: Non-Generic Plugin Type Accumulation
+// ============================================================================
+
+describe('Plugin System - Non-Generic Plugins', () => {
+    it('should accumulate types correctly when using non-generic plugins', () => {
+        const plugin1 = (l: Lambder) => l.addApi('api1', { input: z.void(), output: z.void() }, async (ctx, res) => res.raw({ statusCode: 200, body: '' }));
+        const plugin2 = (l: Lambder) => l.addApi('api2', { input: z.void(), output: z.void() }, async (ctx, res) => res.raw({ statusCode: 200, body: '' }));
+
+        const lambder = new Lambder({ publicPath: '', apiPath: '' })
+            .use(plugin1)
+            .use(plugin2);
+
+        type Contract = typeof lambder.ApiContractType;
+        
+        // Check if both api1 and api2 exist in Contract
+        expectTypeOf<Contract>().toHaveProperty('api1');
+        expectTypeOf<Contract>().toHaveProperty('api2');
+    });
+});