lambder 1.0.5 → 1.0.7

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (4) hide show
  1. package/dist/index.d.ts +5 -6
  2. package/dist/index.js +12 -12
  3. package/package.json +1 -1
  4. package/src/index.ts +17 -18
package/dist/index.d.ts CHANGED
@@ -17,14 +17,13 @@ type RawResolvedContext = {
17
17
  };
18
18
  type RenderContext = RawResolvedContext & {
19
19
  runContext: Context;
20
- resolver: Resolver;
21
20
  };
22
21
  type ConditionFunction = (renderContext: RenderContext) => boolean | Promise<boolean>;
23
- type ActionFunction = (renderContext: RenderContext) => ResolverResponse | Promise<ResolverResponse>;
22
+ type ActionFunction = (renderContext: RenderContext, resolver: Resolver) => ResolverResponse | Promise<ResolverResponse>;
24
23
  type HookCreatedFunction = (lambderInstance: Lambder) => Promise<void>;
25
- type HookBeforeRenderFunction = (renderContext: RenderContext) => RenderContext | Promise<RenderContext>;
26
- type HookAfterRenderFunction = (renderContext: RenderContext, renderResult: ResolverResponse) => ResolverResponse | Promise<ResolverResponse>;
27
- type HookFallbackFunction = (renderContext: RenderContext) => ResolverResponse | Promise<ResolverResponse>;
24
+ type HookBeforeRenderFunction = (renderContext: RenderContext, resolver: Resolver) => RenderContext | Promise<RenderContext>;
25
+ type HookAfterRenderFunction = (renderContext: RenderContext, resolver: Resolver, renderResult: ResolverResponse) => ResolverResponse | Promise<ResolverResponse>;
26
+ type HookFallbackFunction = (renderContext: RenderContext, resolver: Resolver) => ResolverResponse | Promise<ResolverResponse>;
28
27
  type HookCompletedFunction = (renderResult: ResolverResponse) => ResolverResponse | Promise<ResolverResponse>;
29
28
  export declare const resolveEvent: (event: APIGatewayProxyEvent, resolve: Function, reject: Function) => RawResolvedContext;
30
29
  export default class Lambder {
@@ -44,7 +43,7 @@ export default class Lambder {
44
43
  });
45
44
  private apiHandler;
46
45
  private pathHandler;
47
- setFallbackHandler(fallbackHandler: (renderContext: RenderContext) => ResolverResponse): void;
46
+ setFallbackHandler(fallbackHandler: (renderContext: RenderContext, resolver: Resolver) => ResolverResponse): void;
48
47
  setGlobalErrorHandler(globalErrorHandler: (err: Error) => ResolverResponse): void;
49
48
  addApi(condition: string | ConditionFunction | RegExp, actionFn: ActionFunction): void;
50
49
  addPath(condition: string | ConditionFunction | RegExp, actionFn: ActionFunction): void;
package/dist/index.js CHANGED
@@ -46,13 +46,13 @@ export default class Lambder {
46
46
  "completed": []
47
47
  };
48
48
  }
49
- async apiHandler(renderContext, actionFn) {
49
+ async apiHandler(renderContext, resolver, actionFn) {
50
50
  // Do context stuff;
51
- return await actionFn(renderContext);
51
+ return await actionFn(renderContext, resolver);
52
52
  }
53
- async pathHandler(renderContext, actionFn) {
53
+ async pathHandler(renderContext, resolver, actionFn) {
54
54
  // Do context stuff;
55
- return await actionFn(renderContext);
55
+ return await actionFn(renderContext, resolver);
56
56
  }
57
57
  setFallbackHandler(fallbackHandler) {
58
58
  this.fallbackHandler = fallbackHandler;
@@ -76,7 +76,7 @@ export default class Lambder {
76
76
  }
77
77
  this._actionList.push({
78
78
  conditionFn,
79
- actionFn: async (renderContext) => await this.apiHandler(renderContext, actionFn)
79
+ actionFn: async (renderContext, resolver) => await this.apiHandler(renderContext, resolver, actionFn)
80
80
  });
81
81
  }
82
82
  addPath(condition, actionFn) {
@@ -95,7 +95,7 @@ export default class Lambder {
95
95
  }
96
96
  this._actionList.push({
97
97
  conditionFn,
98
- actionFn: async (renderContext) => await this.pathHandler(renderContext, actionFn)
98
+ actionFn: async (renderContext, resolver) => await this.pathHandler(renderContext, resolver, actionFn)
99
99
  });
100
100
  }
101
101
  async addHook(hookEvent, hookFn, priority = 0) {
@@ -119,7 +119,7 @@ export default class Lambder {
119
119
  resolve, reject,
120
120
  });
121
121
  const eventContext = resolveEvent(event, resolve, reject);
122
- let renderContext = { ...eventContext, runContext, resolver };
122
+ let renderContext = { ...eventContext, runContext };
123
123
  if (renderContext.method === "OPTIONS")
124
124
  return resolver.cors();
125
125
  let firstMatchedAction = null;
@@ -132,19 +132,19 @@ export default class Lambder {
132
132
  }
133
133
  if (firstMatchedAction) {
134
134
  for (const hook of this._hookList["beforeRender"]) {
135
- renderContext = await hook.hookFn(renderContext);
135
+ renderContext = await hook.hookFn(renderContext, resolver);
136
136
  }
137
- let renderResult = await firstMatchedAction.actionFn(renderContext);
137
+ let renderResult = await firstMatchedAction.actionFn(renderContext, resolver);
138
138
  for (const hook of this._hookList["afterRender"]) {
139
- renderResult = await hook.hookFn(renderContext, renderResult);
139
+ renderResult = await hook.hookFn(renderContext, resolver, renderResult);
140
140
  }
141
141
  resolve(renderResult);
142
142
  }
143
143
  else {
144
144
  for (const hook of this._hookList["fallback"])
145
- await hook.hookFn(renderContext);
145
+ await hook.hookFn(renderContext, resolver);
146
146
  if (this.fallbackHandler) {
147
- const renderResult = await this.fallbackHandler(renderContext);
147
+ const renderResult = await this.fallbackHandler(renderContext, resolver);
148
148
  resolve(renderResult);
149
149
  }
150
150
  else {
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "lambder",
3
- "version": "1.0.5",
3
+ "version": "1.0.7",
4
4
  "description": "",
5
5
  "main": "dist/index.js",
6
6
  "types": "dist/index.d.ts",
package/src/index.ts CHANGED
@@ -16,17 +16,16 @@ type RawResolvedContext = {
16
16
 
17
17
  type RenderContext = RawResolvedContext & {
18
18
  runContext: Context,
19
- resolver: Resolver,
20
19
  }
21
20
 
22
21
  type ConditionFunction = (renderContext: RenderContext) => boolean|Promise<boolean>;
23
- type ActionFunction = (renderContext: RenderContext) => ResolverResponse|Promise<ResolverResponse>;
22
+ type ActionFunction = (renderContext: RenderContext, resolver: Resolver) => ResolverResponse|Promise<ResolverResponse>;
24
23
  type ActionType = { conditionFn: ConditionFunction, actionFn: ActionFunction };
25
24
 
26
25
  type HookCreatedFunction = (lambderInstance: Lambder) => Promise<void>;
27
- type HookBeforeRenderFunction = (renderContext: RenderContext) => RenderContext|Promise<RenderContext>;
28
- type HookAfterRenderFunction = (renderContext: RenderContext, renderResult: ResolverResponse) => ResolverResponse|Promise<ResolverResponse>;
29
- type HookFallbackFunction = (renderContext: RenderContext) => ResolverResponse|Promise<ResolverResponse>;
26
+ type HookBeforeRenderFunction = (renderContext: RenderContext, resolver: Resolver) => RenderContext|Promise<RenderContext>;
27
+ type HookAfterRenderFunction = (renderContext: RenderContext, resolver: Resolver, renderResult: ResolverResponse) => ResolverResponse|Promise<ResolverResponse>;
28
+ type HookFallbackFunction = (renderContext: RenderContext, resolver: Resolver) => ResolverResponse|Promise<ResolverResponse>;
30
29
  type HookCompletedFunction = (renderResult: ResolverResponse) => ResolverResponse|Promise<ResolverResponse>;
31
30
 
32
31
  type HookEventType = "created"|"beforeRender"|"afterRender"|"fallback"|"completed";
@@ -91,15 +90,15 @@ export default class Lambder {
91
90
  };
92
91
  }
93
92
 
94
- private async apiHandler (renderContext:RenderContext, actionFn: ActionFunction){
93
+ private async apiHandler (renderContext:RenderContext, resolver: Resolver, actionFn: ActionFunction){
95
94
  // Do context stuff;
96
- return await actionFn(renderContext);
95
+ return await actionFn(renderContext, resolver);
97
96
  }
98
- private async pathHandler (renderContext:RenderContext, actionFn: ActionFunction){
97
+ private async pathHandler (renderContext:RenderContext, resolver: Resolver, actionFn: ActionFunction){
99
98
  // Do context stuff;
100
- return await actionFn(renderContext);
99
+ return await actionFn(renderContext, resolver);
101
100
  }
102
- setFallbackHandler(fallbackHandler: (renderContext:RenderContext)=>ResolverResponse){
101
+ setFallbackHandler(fallbackHandler: (renderContext:RenderContext, resolver: Resolver)=>ResolverResponse){
103
102
  this.fallbackHandler = fallbackHandler;
104
103
  }
105
104
  setGlobalErrorHandler(globalErrorHandler: (err: Error)=>ResolverResponse){
@@ -120,7 +119,7 @@ export default class Lambder {
120
119
  }else { throw "Unsupported API Condition"; }
121
120
  this._actionList.push({
122
121
  conditionFn,
123
- actionFn: async (renderContext:RenderContext) => await this.apiHandler(renderContext, actionFn)
122
+ actionFn: async (renderContext:RenderContext, resolver: Resolver) => await this.apiHandler(renderContext, resolver, actionFn)
124
123
  });
125
124
  }
126
125
 
@@ -138,7 +137,7 @@ export default class Lambder {
138
137
  }else { throw "Unsupported Path Condition"; }
139
138
  this._actionList.push({
140
139
  conditionFn,
141
- actionFn: async (renderContext:RenderContext) => await this.pathHandler(renderContext, actionFn)
140
+ actionFn: async (renderContext:RenderContext, resolver: Resolver) => await this.pathHandler(renderContext, resolver, actionFn)
142
141
  });
143
142
  }
144
143
 
@@ -182,7 +181,7 @@ export default class Lambder {
182
181
  resolve, reject,
183
182
  });
184
183
  const eventContext:RawResolvedContext = resolveEvent(event, resolve, reject);
185
- let renderContext:RenderContext = { ...eventContext, runContext, resolver };
184
+ let renderContext:RenderContext = { ...eventContext, runContext };
186
185
 
187
186
  if(renderContext.method === "OPTIONS") return resolver.cors();
188
187
 
@@ -197,17 +196,17 @@ export default class Lambder {
197
196
 
198
197
  if(firstMatchedAction){
199
198
  for(const hook of this._hookList["beforeRender"]){
200
- renderContext = await hook.hookFn(renderContext);
199
+ renderContext = await hook.hookFn(renderContext, resolver);
201
200
  }
202
- let renderResult = await firstMatchedAction.actionFn(renderContext);
201
+ let renderResult = await firstMatchedAction.actionFn(renderContext, resolver);
203
202
  for(const hook of this._hookList["afterRender"]){
204
- renderResult = await hook.hookFn(renderContext, renderResult);
203
+ renderResult = await hook.hookFn(renderContext, resolver, renderResult);
205
204
  }
206
205
  resolve(renderResult);
207
206
  }else{
208
- for(const hook of this._hookList["fallback"]) await hook.hookFn(renderContext);
207
+ for(const hook of this._hookList["fallback"]) await hook.hookFn(renderContext, resolver);
209
208
  if(this.fallbackHandler){
210
- const renderResult = await this.fallbackHandler(renderContext);
209
+ const renderResult = await this.fallbackHandler(renderContext, resolver);
211
210
  resolve(renderResult);
212
211
  }else{
213
212
  resolve({ statusCode: 204, body: "Fallback handler not set.", })