lambder 2.0.4 → 2.0.5

package/Readme.md

@@ -70,7 +70,7 @@ const app = lambder
     });
 
 // Export the inferred contract for the frontend
-export type AppContract = typeof lambder.ApiContractType;
+export type AppContract = typeof lambder.ApiContract;
 
 // Export the handler
 export const handler = lambder.getHandler();
@@ -196,7 +196,7 @@ import { userApi } from "./user-api";
 const lambder = new Lambder()
     .use(userApi);
 
-export type AppContract = typeof lambder.ApiContractType;
+export type AppContract = typeof lambder.ApiContract;
 ```
 
 
@@ -457,7 +457,7 @@ const lambder = new Lambder({ apiPath: '/api' })
         return res.api({ id: ctx.apiPayload.userId, name: "John" });
     });
 
-export type AppContract = typeof lambder.ApiContractType;
+export type AppContract = typeof lambder.ApiContract;
 export const handler = lambder.getHandler();
 ```
 

package/dist/Lambder.d.ts

@@ -77,10 +77,10 @@ export default class Lambder<TSessionData = any, _TContract extends Record<strin
      * @example
      * ```typescript
      * const lambder = new Lambder().addApi(...).addApi(...);
-     * export type AppContract = typeof lambder.ApiContractType;
+     * export type AppContract = typeof lambder.ApiContract;
      * ```
      */
-    readonly ApiContractType: _TContract;
+    readonly ApiContract: _TContract;
     private actionList;
     private hookList;
     private globalErrorHandler;

package/dist/Lambder.js

@@ -76,10 +76,10 @@ export default class Lambder {
      * @example
      * ```typescript
      * const lambder = new Lambder().addApi(...).addApi(...);
-     * export type AppContract = typeof lambder.ApiContractType;
+     * export type AppContract = typeof lambder.ApiContract;
      * ```
      */
-    ApiContractType;
+    ApiContract;
     actionList;
     hookList;
     globalErrorHandler = null;

package/dist/LambderApiContract.d.ts

@@ -1,7 +1,7 @@
 /**
  * Lambder API Contract System
  *
- * Contracts are built via method chaining and inferred using typeof lambder.ApiContractType
+ * Contracts are built via method chaining and inferred using typeof lambder.ApiContract
  */
 /**
  * Base shape for API contracts - used by LambderCaller and LambderMSW

package/dist/LambderApiContract.js

@@ -1,6 +1,6 @@
 /**
  * Lambder API Contract System
  *
- * Contracts are built via method chaining and inferred using typeof lambder.ApiContractType
+ * Contracts are built via method chaining and inferred using typeof lambder.ApiContract
  */
 export {};

package/docs/LAMBDER_MSW.md

@@ -56,23 +56,32 @@ afterAll(() => server.close());
 When using TypeScript API contracts, LambderMSW provides full type safety:
 
 ```typescript
-// shared/apiContract.ts
-import type { ApiContract } from 'lambder';
-
-export type MyApiContract = ApiContract<{
-    getUserById: { 
-        input: { userId: string }, 
-        output: { id: string, name: string, email: string } 
-    },
-    createUser: { 
-        input: { name: string, email: string }, 
-        output: { id: string, name: string, email: string } 
-    }
-}>;
+// backend/index.ts (define your APIs with Lambder)
+import { z } from 'zod';
+import Lambder from 'lambder';
+
+const lambder = new Lambder({ apiPath: '/secure' })
+    .addApi('getUserById', {
+        input: z.object({ userId: z.string() }),
+        output: z.object({ id: z.string(), name: z.string(), email: z.string() })
+    }, async (ctx, resolver) => {
+        // Implementation...
+        return resolver.api({ id: ctx.apiPayload.userId, name: 'John', email: 'john@example.com' });
+    })
+    .addApi('createUser', {
+        input: z.object({ name: z.string(), email: z.string() }),
+        output: z.object({ id: z.string(), name: z.string(), email: z.string() })
+    }, async (ctx, resolver) => {
+        // Implementation...
+        return resolver.api({ id: '123', ...ctx.apiPayload });
+    });
+
+// Export the inferred contract type
+export type MyApiContract = typeof lambder.ApiContract;
 
 // test/setup.ts
 import { LambderMSW } from 'lambder';
-import type { MyApiContract } from '../shared/apiContract';
+import type { MyApiContract } from '../backend';
 
 const lambderMSW = new LambderMSW<MyApiContract>({
     apiPath: '/secure',
@@ -208,7 +217,7 @@ import { describe, it, expect, beforeAll, afterAll, afterEach } from 'vitest';
 import { setupServer } from 'msw/node';
 import { LambderMSW } from 'lambder';
 import { LambderCaller } from 'lambder';
-import type { MyApiContract } from '../shared/apiContract';
+import type { MyApiContract } from '../backend'; // Type-only import from your backend
 
 // Setup MSW
 const lambderMSW = new LambderMSW<MyApiContract>({
@@ -305,7 +314,7 @@ LambderMSW also works in browser environments with MSW's browser integration:
 // test/browser-setup.ts
 import { setupWorker } from 'msw/browser';
 import { LambderMSW } from 'lambder';
-import type { MyApiContract } from '../shared/apiContract';
+import type { MyApiContract } from '../backend'; // Type-only import from your backend
 
 const lambderMSW = new LambderMSW<MyApiContract>({
     apiPath: '/secure'

package/docs/TYPE_SAFE_QUICK_START.md

@@ -29,7 +29,7 @@ const lambder = new Lambder({
 });
 
 // Export the inferred contract type
-export type AppContract = typeof lambder.ApiContractType;
+export type AppContract = typeof lambder.ApiContract;
 
 export const handler = lambder.getHandler();
 ```

package/examples/msw-testing-example.ts

@@ -40,7 +40,7 @@ const lambder = new Lambder()
         output: z.object({ success: z.boolean() })
     }, async () => ({} as any));
 
-type TestApiContract = typeof lambder.ApiContractType;
+type TestApiContract = typeof lambder.ApiContract;
 
 // Setup LambderMSW with type safety
 const lambderMSW = new LambderMSW<TestApiContract>({

package/examples/zod-chained-api-example.ts

@@ -46,7 +46,7 @@ const lambder = new Lambder({
     });
 
 // 3. Export the inferred contract type for Frontend
-export type AppContract = typeof lambder.ApiContractType;
+export type AppContract = typeof lambder.ApiContract;
 
 // 4. Modular example using .use()
 const authApi = <T>(l: Lambder<T>) => {
@@ -60,4 +60,4 @@ const authApi = <T>(l: Lambder<T>) => {
 
 const lambderWithAuth = lambder.use(authApi);
 
-export type AuthContract = typeof lambderWithAuth.ApiContractType;
+export type AuthContract = typeof lambderWithAuth.ApiContract;

package/package.json

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

package/src/Lambder.ts

@@ -133,10 +133,10 @@ export default class Lambder<TSessionData = any, _TContract extends Record<strin
      * @example
      * ```typescript
      * const lambder = new Lambder().addApi(...).addApi(...);
-     * export type AppContract = typeof lambder.ApiContractType;
+     * export type AppContract = typeof lambder.ApiContract;
      * ```
      */
-    public readonly ApiContractType!: _TContract;
+    public readonly ApiContract!: _TContract;
     
     private actionList: ActionObject[];
     private hookList: { 

package/src/LambderApiContract.ts

@@ -1,7 +1,7 @@
 /**
  * Lambder API Contract System
  * 
- * Contracts are built via method chaining and inferred using typeof lambder.ApiContractType
+ * Contracts are built via method chaining and inferred using typeof lambder.ApiContract
  */
 
 /**

package/tests/type-safety.test.ts

@@ -34,7 +34,7 @@ describe('LambderCaller Type Safety', () => {
             return resolver.api({ id: '1', ...ctx.apiPayload });
         });
 
-        type TestApiContract = typeof lambder.ApiContractType;
+        type TestApiContract = typeof lambder.ApiContract;
 
         const caller = new LambderCaller<TestApiContract>({
             apiPath: '/api',
@@ -181,7 +181,7 @@ describe('apiRaw Method Type Safety', () => {
             return resolver.api({ id: ctx.apiPayload.userId, name: 'Test' });
         });
 
-        type TestApiContract = typeof lambder.ApiContractType;
+        type TestApiContract = typeof lambder.ApiContract;
 
         const caller = new LambderCaller<TestApiContract>({
             apiPath: '/api',

package/tests/use-plugin.test.ts

@@ -70,7 +70,7 @@ describe('Plugin System - Basic Usage', () => {
         const result = await handler(event, createMockContext());
 
         expect(result.statusCode).toBe(200);
-        const body = JSON.parse(result.body);
+        const body = JSON.parse(result.body || '{}');
         expect(body.payload).toEqual({ id: '123', name: 'John Doe' });
     });
 
@@ -90,7 +90,7 @@ describe('Plugin System - Basic Usage', () => {
             apiPath: '/api'
         }).use(userPlugin);
 
-        type AppContract = typeof lambder.ApiContractType;
+        type AppContract = typeof lambder.ApiContract;
 
         const caller = new LambderCaller<AppContract>({
             apiPath: '/api',
@@ -163,19 +163,19 @@ describe('Plugin System - Multiple Plugins', () => {
         const userEvent = createMockEvent('getUser', { userId: '123' });
         const userResult = await handler(userEvent, createMockContext());
         expect(userResult.statusCode).toBe(200);
-        expect(JSON.parse(userResult.body).payload.name).toBe('John');
+        expect(JSON.parse(userResult.body || '{}').payload.name).toBe('John');
 
         // Test product API
         const productEvent = createMockEvent('getProduct', { productId: 'prod-456' });
         const productResult = await handler(productEvent, createMockContext());
         expect(productResult.statusCode).toBe(200);
-        expect(JSON.parse(productResult.body).payload.title).toBe('Test Product');
+        expect(JSON.parse(productResult.body || '{}').payload.title).toBe('Test Product');
 
         // Test order API
         const orderEvent = createMockEvent('createOrder', { userId: '123', productId: 'prod-456' });
         const orderResult = await handler(orderEvent, createMockContext());
         expect(orderResult.statusCode).toBe(200);
-        expect(JSON.parse(orderResult.body).payload.orderId).toBe('order-123');
+        expect(JSON.parse(orderResult.body || '{}').payload.orderId).toBe('order-123');
     });
 
     it('should accumulate types from multiple plugins', () => {
@@ -206,7 +206,7 @@ describe('Plugin System - Multiple Plugins', () => {
             .use(userPlugin)
             .use(productPlugin);
 
-        type AppContract = typeof lambder.ApiContractType;
+        type AppContract = typeof lambder.ApiContract;
 
         const caller = new LambderCaller<AppContract>({
             apiPath: '/api',
@@ -263,17 +263,17 @@ describe('Plugin System - Mixed Usage', () => {
         // Test direct API before plugin
         const healthEvent = createMockEvent('healthCheck', undefined);
         const healthResult = await handler(healthEvent, createMockContext());
-        expect(JSON.parse(healthResult.body).payload.status).toBe('ok');
+        expect(JSON.parse(healthResult.body || '{}').payload.status).toBe('ok');
 
         // Test plugin API
         const userEvent = createMockEvent('getUser', { userId: '123' });
         const userResult = await handler(userEvent, createMockContext());
-        expect(JSON.parse(userResult.body).payload.name).toBe('John');
+        expect(JSON.parse(userResult.body || '{}').payload.name).toBe('John');
 
         // Test direct API after plugin
         const versionEvent = createMockEvent('getVersion', undefined);
         const versionResult = await handler(versionEvent, createMockContext());
-        expect(JSON.parse(versionResult.body).payload.version).toBe('2.0');
+        expect(JSON.parse(versionResult.body || '{}').payload.version).toBe('2.0');
     });
 });
 
@@ -424,7 +424,7 @@ describe('Plugin System - Type Safety', () => {
             .use(plugin1)
             .use(plugin2);
 
-        type Contract = typeof lambder.ApiContractType;
+        type Contract = typeof lambder.ApiContract;
 
         // Type assertions - both api1 and api2 should be in the contract
         // We test this at runtime by creating a caller
@@ -446,12 +446,14 @@ describe('Plugin System - Non-Generic Plugins', () => {
         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: '' })
+            .addApi('initialApi', { input: z.void(), output: z.void() }, async (ctx, res) => res.raw({ statusCode: 200, body: '' }))
             .use(plugin1)
             .use(plugin2);
 
-        type Contract = typeof lambder.ApiContractType;
+        type Contract = typeof lambder.ApiContract;
         
         // Check if both api1 and api2 exist in Contract
+        expectTypeOf<Contract>().toHaveProperty('initialApi');
         expectTypeOf<Contract>().toHaveProperty('api1');
         expectTypeOf<Contract>().toHaveProperty('api2');
     });