lambder 7.2.4 → 7.2.5

package/dist/core/Lambder.d.ts

@@ -60,10 +60,17 @@ export default class Lambder<TSessionData = any, _TContract extends Record<strin
      * Type property for extracting the API contract
      * Use this to export your API types to the frontend
      *
+     * Export it as an interface extending LambderFlattenContract, not as a
+     * type alias. Chaining builds the contract as an intersection one member
+     * deep per endpoint, and an interface collapses that into one declared
+     * set of members, which every generic read of the contract (a mock
+     * registry, a needs map, the typed caller) is then far cheaper against.
+     * See LambderFlattenContract for the measurements.
+     *
      * @example
      * ```typescript
      * const lambder = new Lambder().addApi(...).addApi(...);
-     * export type ApiContractType = typeof lambder.ApiContract;
+     * export interface ApiContractType extends LambderFlattenContract<typeof lambder.ApiContract> {}
      * ```
      */
     readonly ApiContract: _TContract;

package/dist/core/Lambder.js

@@ -55,10 +55,17 @@ export default class Lambder {
      * Type property for extracting the API contract
      * Use this to export your API types to the frontend
      *
+     * Export it as an interface extending LambderFlattenContract, not as a
+     * type alias. Chaining builds the contract as an intersection one member
+     * deep per endpoint, and an interface collapses that into one declared
+     * set of members, which every generic read of the contract (a mock
+     * registry, a needs map, the typed caller) is then far cheaper against.
+     * See LambderFlattenContract for the measurements.
+     *
      * @example
      * ```typescript
      * const lambder = new Lambder().addApi(...).addApi(...);
-     * export type ApiContractType = typeof lambder.ApiContract;
+     * export interface ApiContractType extends LambderFlattenContract<typeof lambder.ApiContract> {}
      * ```
      */
     ApiContract;

package/dist/index.d.ts

@@ -104,7 +104,7 @@ export type { LambderApiIdempotencyConfig } from "./api/LambderApiIdempotency.js
 export type { LambderGuardsOptionValue, LambderRateLimitOverride, LambderRateLimitOptionValue, LambderApiIdempotencyOption, } from "./shared/wire/LambderApiOptionValues.js";
 export { createLambderI18n } from "./shared/LambderI18n.js";
 export type { LambderLanguageMeta, LambderI18nConfig, LambderI18nInstance, LambderI18nTranslator, LambderI18nExtractParams, LambderI18nDictionaryLoader, LambderI18nCodes, LambderI18nKeys, LambderI18nTranslatorFor, } from "./shared/LambderI18n.js";
-export type { LambderApiContractShape, LambderApiMode, LambderApiEnvelopeBody, LambderApiResponseConfig, LambderApiNullAnswerConfig, LambderContractEntry, LambderMergeContract, LambderGuardNamesIn, LambderContractMode, LambderContractKeysWithMode, LambderContractGuardsOf, LambderContractGuardNames, LambderContractGuardInputsOf, LambderContractGuardInput, LambderContractGuardInputNames, LambderContractRateLimitOf, LambderContractRateLimitNames, LambderContractIdempotencyOf, } from "./shared/wire/LambderApiContract.js";
+export type { LambderApiContractShape, LambderApiMode, LambderApiEnvelopeBody, LambderApiResponseConfig, LambderApiNullAnswerConfig, LambderContractEntry, LambderMergeContract, LambderFlattenContract, LambderGuardNamesIn, LambderContractMode, LambderContractKeysWithMode, LambderContractGuardsOf, LambderContractGuardNames, LambderContractGuardInputsOf, LambderContractGuardInput, LambderContractGuardInputNames, LambderContractRateLimitOf, LambderContractRateLimitNames, LambderContractIdempotencyOf, } from "./shared/wire/LambderApiContract.js";
 export type { LambderRenderContext, LambderSessionRenderContext, LambderHttpEvent, LambderHttpEventFormat } from "./core/LambderContext.js";
 export type { LambderApiAnswerOutcome, LambderApiSuccessOutcome, LambderApiCallFailure, LambderApiValidationFailure, LambderApiEnvelopeFailure, LambderApiHttpAnswer, } from "./shared/wire/LambderApiOutcome.js";
 export { resolveApiOutcome } from "./shared/wire/LambderApiOutcome.js";

package/dist/shared/wire/LambderApiContract.d.ts

@@ -85,6 +85,56 @@ export type LambderContractEntry<In, Out, Mode extends LambderApiMode, GuardInpu
 export type LambderMergeContract<Old, Name extends string, Entry> = Old & {
     [K in Name]: Entry;
 };
+/**
+ * The contract as one object type, for the `export interface` a consuming
+ * app declares its contract through:
+ *
+ * ```ts
+ * export interface ApiContractType extends LambderFlattenContract<typeof lambder.ApiContract> {}
+ * ```
+ *
+ * Chaining leaves the contract an intersection one member deep per endpoint
+ * (LambderMergeContract above), and every `C[K]` written against a type
+ * parameter then resolves the property across all of them. That lookup is
+ * the atom the reading helpers below are built from, so its cost is paid
+ * again by each of them, per endpoint, in every app that registers a mock,
+ * declares a needs map, or otherwise reads the contract generically: in a
+ * 182-endpoint app one indexed access measured ~3,000 type instantiations
+ * and one mock registration ~18,000.
+ *
+ * Extending an interface is what collapses it. An interface's members are
+ * declared, so they are resolved once for the whole declaration rather than
+ * per lookup, and the same access measured ~6 instantiations after the
+ * change: a 182-endpoint app's frontend type check went from 27.8M
+ * instantiations to 7.0M and from 20.2s to 10.6s of check time. The alias
+ * form (`type C = LambderFlattenContract<...>`) does NOT do this: a mapped
+ * type stays deferred and each lookup pays the full cost again, so the
+ * `interface ... extends` spelling is the point.
+ *
+ * Diagnostics are the same ones, and they read better: a message naming the
+ * contract prints the interface by name, where the intersection is printed
+ * as a truncated spill of entries.
+ *
+ * Every endpoint name must be a string literal for an interface to extend
+ * the result, which registration through addApi/addSessionApi guarantees.
+ *
+ * Two things quietly undo it, both of which look like tidying:
+ *
+ * - `@typescript-eslint/no-empty-object-type` reports the empty body as
+ *   "equivalent to its supertype" and its fix is a type alias, which is the
+ *   one spelling that does not collapse anything. Disable the rule on the
+ *   line rather than taking the fix.
+ * - Extending anything but a mapped type loses the inferable index signature.
+ *   An interface has none of its own, so a hand-written `interface C { ... }`
+ *   is not assignable to LambderApiContractShape and is rejected by
+ *   initLambderMock<C>, LambderCaller<C> and LambderInvokeCaller<C>;
+ *   extending this mapped type is what keeps it. api-contract.test.ts pins
+ *   that, along with the flattened contract being the same type member for
+ *   member.
+ */
+export type LambderFlattenContract<C> = {
+    [K in keyof C]: C[K];
+};
 /** Guard names referenced by a guards option, whichever of its three forms is used. */
 export type LambderGuardNamesIn<TOpt> = TOpt extends string ? TOpt : TOpt extends readonly (infer N extends string)[] ? N : TOpt extends object ? keyof TOpt & string : never;
 /** The endpoint's mode; a contract written without one admits either. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lambder",
-  "version": "7.2.4",
+  "version": "7.2.5",
   "sideEffects": false,
   "description": "Opinionated serverless web framework for TypeScript on AWS Lambda: type-safe APIs from Zod schemas, DynamoDB sessions, and declarative rate limits, authorization guards and idempotency.",
   "keywords": [