lambder 1.0.4 → 1.0.6
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.
- package/dist/index.d.ts +4 -5
- package/dist/index.js +18 -18
- package/package.json +1 -1
- package/src/index.ts +28 -23
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 {
|
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;
|
|
@@ -63,39 +63,39 @@ export default class Lambder {
|
|
|
63
63
|
addApi(condition, actionFn) {
|
|
64
64
|
let conditionFn = (renderContext) => false;
|
|
65
65
|
if (typeof condition === "string") {
|
|
66
|
-
conditionFn = (renderContext) => renderContext.url === this.apiPath && (renderContext.post?.api) === condition;
|
|
66
|
+
conditionFn = (renderContext) => renderContext.method === "POST" && renderContext.url === this.apiPath && (renderContext.post?.api) === condition;
|
|
67
67
|
}
|
|
68
68
|
else if (typeof condition === "function") {
|
|
69
|
-
conditionFn = async (renderContext) => renderContext.url === this.apiPath && (await condition(renderContext));
|
|
69
|
+
conditionFn = async (renderContext) => renderContext.method === "POST" && renderContext.url === this.apiPath && (await condition(renderContext));
|
|
70
70
|
}
|
|
71
71
|
else if (condition?.constructor == RegExp) {
|
|
72
|
-
conditionFn = (renderContext) => renderContext.url === this.apiPath && condition.test(renderContext.post?.api);
|
|
72
|
+
conditionFn = (renderContext) => renderContext.method === "POST" && renderContext.url === this.apiPath && condition.test(renderContext.post?.api);
|
|
73
73
|
}
|
|
74
74
|
else {
|
|
75
75
|
throw "Unsupported API Condition";
|
|
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) {
|
|
83
83
|
let conditionFn = (renderContext) => false;
|
|
84
84
|
if (typeof condition === "string") {
|
|
85
|
-
conditionFn = (renderContext) => renderContext.url === condition;
|
|
85
|
+
conditionFn = (renderContext) => renderContext.method === "GET" && renderContext.url === condition;
|
|
86
86
|
}
|
|
87
87
|
else if (typeof condition === "function") {
|
|
88
|
-
conditionFn = async (renderContext) => (await condition(renderContext));
|
|
88
|
+
conditionFn = async (renderContext) => renderContext.method === "GET" && (await condition(renderContext));
|
|
89
89
|
}
|
|
90
90
|
else if (condition?.constructor == RegExp) {
|
|
91
|
-
conditionFn = (renderContext) => condition.test(renderContext.url);
|
|
91
|
+
conditionFn = (renderContext) => renderContext.method === "GET" && condition.test(renderContext.url);
|
|
92
92
|
}
|
|
93
93
|
else {
|
|
94
94
|
throw "Unsupported Path Condition";
|
|
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
|
|
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
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,13 +90,13 @@ 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
101
|
setFallbackHandler(fallbackHandler: (renderContext:RenderContext)=>ResolverResponse){
|
|
103
102
|
this.fallbackHandler = fallbackHandler;
|
|
@@ -109,30 +108,36 @@ export default class Lambder {
|
|
|
109
108
|
addApi(condition: string|ConditionFunction|RegExp, actionFn: ActionFunction):void{
|
|
110
109
|
let conditionFn: ConditionFunction = (renderContext:RenderContext) => false;
|
|
111
110
|
if(typeof condition === "string"){
|
|
112
|
-
conditionFn = (renderContext:RenderContext) =>
|
|
111
|
+
conditionFn = (renderContext:RenderContext) =>
|
|
112
|
+
renderContext.method === "POST" && renderContext.url === this.apiPath && (renderContext.post?.api) === condition;
|
|
113
113
|
}else if(typeof condition === "function"){
|
|
114
|
-
conditionFn = async (renderContext:RenderContext) =>
|
|
114
|
+
conditionFn = async (renderContext:RenderContext) =>
|
|
115
|
+
renderContext.method === "POST" && renderContext.url === this.apiPath && (await condition(renderContext));
|
|
115
116
|
}else if(condition?.constructor == RegExp){
|
|
116
|
-
conditionFn = (renderContext:RenderContext) =>
|
|
117
|
+
conditionFn = (renderContext:RenderContext) =>
|
|
118
|
+
renderContext.method === "POST" && renderContext.url === this.apiPath && condition.test(renderContext.post?.api);
|
|
117
119
|
}else { throw "Unsupported API Condition"; }
|
|
118
120
|
this._actionList.push({
|
|
119
121
|
conditionFn,
|
|
120
|
-
actionFn: async (renderContext:RenderContext) => await this.apiHandler(renderContext, actionFn)
|
|
122
|
+
actionFn: async (renderContext:RenderContext, resolver: Resolver) => await this.apiHandler(renderContext, resolver, actionFn)
|
|
121
123
|
});
|
|
122
124
|
}
|
|
123
125
|
|
|
124
126
|
addPath(condition: string|ConditionFunction|RegExp, actionFn: ActionFunction):void{
|
|
125
127
|
let conditionFn: ConditionFunction = (renderContext:RenderContext) => false;
|
|
126
128
|
if(typeof condition === "string"){
|
|
127
|
-
conditionFn = (renderContext:RenderContext) =>
|
|
129
|
+
conditionFn = (renderContext:RenderContext) =>
|
|
130
|
+
renderContext.method === "GET" && renderContext.url === condition;
|
|
128
131
|
}else if(typeof condition === "function"){
|
|
129
|
-
conditionFn = async (renderContext:RenderContext) =>
|
|
132
|
+
conditionFn = async (renderContext:RenderContext) =>
|
|
133
|
+
renderContext.method === "GET" && (await condition(renderContext));
|
|
130
134
|
}else if(condition?.constructor == RegExp){
|
|
131
|
-
conditionFn = (renderContext:RenderContext) =>
|
|
135
|
+
conditionFn = (renderContext:RenderContext) =>
|
|
136
|
+
renderContext.method === "GET" && condition.test(renderContext.url);
|
|
132
137
|
}else { throw "Unsupported Path Condition"; }
|
|
133
138
|
this._actionList.push({
|
|
134
139
|
conditionFn,
|
|
135
|
-
actionFn: async (renderContext:RenderContext) => await this.pathHandler(renderContext, actionFn)
|
|
140
|
+
actionFn: async (renderContext:RenderContext, resolver: Resolver) => await this.pathHandler(renderContext, resolver, actionFn)
|
|
136
141
|
});
|
|
137
142
|
}
|
|
138
143
|
|
|
@@ -176,7 +181,7 @@ export default class Lambder {
|
|
|
176
181
|
resolve, reject,
|
|
177
182
|
});
|
|
178
183
|
const eventContext:RawResolvedContext = resolveEvent(event, resolve, reject);
|
|
179
|
-
let renderContext:RenderContext = { ...eventContext, runContext
|
|
184
|
+
let renderContext:RenderContext = { ...eventContext, runContext };
|
|
180
185
|
|
|
181
186
|
if(renderContext.method === "OPTIONS") return resolver.cors();
|
|
182
187
|
|
|
@@ -191,17 +196,17 @@ export default class Lambder {
|
|
|
191
196
|
|
|
192
197
|
if(firstMatchedAction){
|
|
193
198
|
for(const hook of this._hookList["beforeRender"]){
|
|
194
|
-
renderContext = await hook.hookFn(renderContext);
|
|
199
|
+
renderContext = await hook.hookFn(renderContext, resolver);
|
|
195
200
|
}
|
|
196
|
-
let renderResult = await firstMatchedAction.actionFn(renderContext);
|
|
201
|
+
let renderResult = await firstMatchedAction.actionFn(renderContext, resolver);
|
|
197
202
|
for(const hook of this._hookList["afterRender"]){
|
|
198
|
-
renderResult = await hook.hookFn(renderContext, renderResult);
|
|
203
|
+
renderResult = await hook.hookFn(renderContext, resolver, renderResult);
|
|
199
204
|
}
|
|
200
205
|
resolve(renderResult);
|
|
201
206
|
}else{
|
|
202
|
-
for(const hook of this._hookList["fallback"]) await hook.hookFn(renderContext);
|
|
207
|
+
for(const hook of this._hookList["fallback"]) await hook.hookFn(renderContext, resolver);
|
|
203
208
|
if(this.fallbackHandler){
|
|
204
|
-
const renderResult = await this.fallbackHandler(renderContext);
|
|
209
|
+
const renderResult = await this.fallbackHandler(renderContext, resolver);
|
|
205
210
|
resolve(renderResult);
|
|
206
211
|
}else{
|
|
207
212
|
resolve({ statusCode: 204, body: "Fallback handler not set.", })
|