@flowerforce/flowerbase 1.3.1-beta.0 → 1.3.1-beta.2

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 (19) hide show
  1. package/dist/services/api/index.d.ts +92 -8
  2. package/dist/services/api/index.d.ts.map +1 -1
  3. package/dist/services/api/index.js +15 -8
  4. package/dist/services/api/model.d.ts +3 -0
  5. package/dist/services/api/model.d.ts.map +1 -1
  6. package/dist/services/api/utils.d.ts +22 -1
  7. package/dist/services/api/utils.d.ts.map +1 -1
  8. package/dist/services/api/utils.js +25 -6
  9. package/dist/services/index.d.ts +92 -8
  10. package/dist/services/index.d.ts.map +1 -1
  11. package/dist/utils/context/helpers.d.ts +349 -8
  12. package/dist/utils/context/helpers.d.ts.map +1 -1
  13. package/dist/utils/context/helpers.js +47 -41
  14. package/package.json +1 -2
  15. package/src/features/functions/controller.ts +1 -1
  16. package/src/services/api/index.ts +18 -8
  17. package/src/services/api/model.ts +3 -0
  18. package/src/services/api/utils.ts +31 -6
  19. package/src/utils/context/helpers.ts +53 -46
package/dist/services/api/index.d.ts CHANGED
@@ -3,34 +3,118 @@ import { DeleteParams, GetParams, PostParams, PutParams } from './model';
3
3
  * > This service is the Api Client that can be imported from the context
4
4
  */
5
5
  declare const Api: () => {
6
- get: <T = null>({ url, headers }: GetParams) => Promise<{
6
+ get: <T = null>({ url, headers, resolveBody }: GetParams) => Promise<{
7
7
  status: number;
8
8
  headers: import("undici/types/header").IncomingHttpHeaders;
9
9
  body: {
10
10
  message: string;
11
11
  };
12
- } | import("undici").Dispatcher.ResponseData<T>>;
13
- post: <T = null>({ scheme, host, path, url: currentUrl, headers, body, encodeBodyAsJSON }: PostParams) => Promise<{
12
+ } | {
13
+ body: {
14
+ text: () => string;
15
+ json: () => any;
16
+ arrayBuffer: () => ArrayBuffer;
17
+ bytes: () => Uint8Array<ArrayBuffer>;
18
+ };
19
+ status: number;
20
+ headers: import("undici/types/header").IncomingHttpHeaders;
21
+ } | import("undici").Dispatcher.ResponseData<T> | {
22
+ body: {
23
+ text: () => string;
24
+ json: () => any;
25
+ arrayBuffer: () => ArrayBuffer;
26
+ bytes: () => Uint8Array<ArrayBuffer>;
27
+ };
28
+ statusCode: number;
29
+ headers: import("undici/types/header").IncomingHttpHeaders;
30
+ trailers: Record<string, string>;
31
+ opaque: T;
32
+ context: object;
33
+ }>;
34
+ post: <T = null>({ scheme, host, path, url: currentUrl, headers, body, encodeBodyAsJSON, resolveBody }: PostParams) => Promise<{
14
35
  status: number;
15
36
  headers: import("undici/types/header").IncomingHttpHeaders;
16
37
  body: {
17
38
  message: string;
18
39
  };
19
- } | import("undici").Dispatcher.ResponseData<T>>;
20
- put: <T = null>({ scheme, host, path, url: currentUrl, headers, body, encodeBodyAsJSON }: PutParams) => Promise<{
40
+ } | {
41
+ body: {
42
+ text: () => string;
43
+ json: () => any;
44
+ arrayBuffer: () => ArrayBuffer;
45
+ bytes: () => Uint8Array<ArrayBuffer>;
46
+ };
47
+ status: number;
48
+ headers: import("undici/types/header").IncomingHttpHeaders;
49
+ } | import("undici").Dispatcher.ResponseData<T> | {
50
+ body: {
51
+ text: () => string;
52
+ json: () => any;
53
+ arrayBuffer: () => ArrayBuffer;
54
+ bytes: () => Uint8Array<ArrayBuffer>;
55
+ };
56
+ statusCode: number;
57
+ headers: import("undici/types/header").IncomingHttpHeaders;
58
+ trailers: Record<string, string>;
59
+ opaque: T;
60
+ context: object;
61
+ }>;
62
+ put: <T = null>({ scheme, host, path, url: currentUrl, headers, body, encodeBodyAsJSON, resolveBody }: PutParams) => Promise<{
21
63
  status: number;
22
64
  headers: import("undici/types/header").IncomingHttpHeaders;
23
65
  body: {
24
66
  message: string;
25
67
  };
26
- } | import("undici").Dispatcher.ResponseData<T>>;
27
- delete: <T = null>({ scheme, host, path, url: currentUrl, headers }: DeleteParams) => Promise<{
68
+ } | {
69
+ body: {
70
+ text: () => string;
71
+ json: () => any;
72
+ arrayBuffer: () => ArrayBuffer;
73
+ bytes: () => Uint8Array<ArrayBuffer>;
74
+ };
75
+ status: number;
76
+ headers: import("undici/types/header").IncomingHttpHeaders;
77
+ } | import("undici").Dispatcher.ResponseData<T> | {
78
+ body: {
79
+ text: () => string;
80
+ json: () => any;
81
+ arrayBuffer: () => ArrayBuffer;
82
+ bytes: () => Uint8Array<ArrayBuffer>;
83
+ };
84
+ statusCode: number;
85
+ headers: import("undici/types/header").IncomingHttpHeaders;
86
+ trailers: Record<string, string>;
87
+ opaque: T;
88
+ context: object;
89
+ }>;
90
+ delete: <T = null>({ scheme, host, path, url: currentUrl, headers, resolveBody }: DeleteParams) => Promise<{
28
91
  status: number;
29
92
  headers: import("undici/types/header").IncomingHttpHeaders;
30
93
  body: {
31
94
  message: string;
32
95
  };
33
- } | import("undici").Dispatcher.ResponseData<T>>;
96
+ } | {
97
+ body: {
98
+ text: () => string;
99
+ json: () => any;
100
+ arrayBuffer: () => ArrayBuffer;
101
+ bytes: () => Uint8Array<ArrayBuffer>;
102
+ };
103
+ status: number;
104
+ headers: import("undici/types/header").IncomingHttpHeaders;
105
+ } | import("undici").Dispatcher.ResponseData<T> | {
106
+ body: {
107
+ text: () => string;
108
+ json: () => any;
109
+ arrayBuffer: () => ArrayBuffer;
110
+ bytes: () => Uint8Array<ArrayBuffer>;
111
+ };
112
+ statusCode: number;
113
+ headers: import("undici/types/header").IncomingHttpHeaders;
114
+ trailers: Record<string, string>;
115
+ opaque: T;
116
+ context: object;
117
+ }>;
34
118
  };
35
119
  export default Api;
36
120
  //# sourceMappingURL=index.d.ts.map
package/dist/services/api/index.d.ts.map CHANGED
@@ -1 +1 @@
1
- {"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/services/api/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,YAAY,EAAE,SAAS,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,SAAS,CAAA;AAGxE;;GAEG;AACH,QAAA,MAAM,GAAG;UACK,CAAC,2BAAgC,SAAS;;;;;;;WAGzC,CAAC,mFAQX,UAAU;;;;;;;UAUD,CAAC,mFAQV,SAAS;;;;;;;aAKG,CAAC,2DAMb,YAAY;;;;;;;CAIf,CAAA;AAEF,eAAe,GAAG,CAAA"}
1
+ {"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/services/api/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,YAAY,EAAE,SAAS,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,SAAS,CAAA;AAGxE;;GAEG;AACH,QAAA,MAAM,GAAG;UACK,CAAC,wCAAoD,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAG7D,CAAC,gGASX,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;UAWD,CAAC,gGASV,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAWG,CAAC,wEAOb,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAIf,CAAA;AAEF,eAAe,GAAG,CAAA"}
package/dist/services/api/index.js CHANGED
@@ -15,27 +15,34 @@ const utils_1 = require("./utils");
15
15
  * > This service is the Api Client that can be imported from the context
16
16
  */
17
17
  const Api = () => ({
18
- get: (_a) => __awaiter(void 0, [_a], void 0, function* ({ url, headers = {} }) {
19
- return (0, utils_1.makeRequest)({ method: 'GET', url, headers });
18
+ get: (_a) => __awaiter(void 0, [_a], void 0, function* ({ url, headers = {}, resolveBody = true }) {
19
+ return (0, utils_1.makeRequest)({ method: 'GET', url, headers, resolveBody });
20
20
  }),
21
- post: (_a) => __awaiter(void 0, [_a], void 0, function* ({ scheme = constants_1.HTTPS_SCHEMA, host, path, url: currentUrl, headers = {}, body, encodeBodyAsJSON = false }) {
21
+ post: (_a) => __awaiter(void 0, [_a], void 0, function* ({ scheme = constants_1.HTTPS_SCHEMA, host, path, url: currentUrl, headers = {}, body, encodeBodyAsJSON = false, resolveBody = true }) {
22
22
  const formattedBody = encodeBodyAsJSON ? JSON.stringify(body) : body;
23
23
  const url = currentUrl ? currentUrl : `${scheme}://${host}/${path}`;
24
24
  return (0, utils_1.makeRequest)({
25
25
  method: 'POST',
26
26
  url,
27
27
  headers: Object.assign({ 'Content-Type': 'application/json' }, headers),
28
- body: formattedBody
28
+ body: formattedBody,
29
+ resolveBody
29
30
  });
30
31
  }),
31
- put: (_a) => __awaiter(void 0, [_a], void 0, function* ({ scheme = constants_1.HTTPS_SCHEMA, host, path, url: currentUrl, headers = {}, body, encodeBodyAsJSON = false }) {
32
+ put: (_a) => __awaiter(void 0, [_a], void 0, function* ({ scheme = constants_1.HTTPS_SCHEMA, host, path, url: currentUrl, headers = {}, body, encodeBodyAsJSON = false, resolveBody = true }) {
32
33
  const formattedBody = encodeBodyAsJSON ? JSON.stringify(body) : body;
33
34
  const url = currentUrl ? currentUrl : `${scheme}://${host}/${path}`;
34
- return (0, utils_1.makeRequest)({ method: 'PUT', url, headers, body: formattedBody });
35
+ return (0, utils_1.makeRequest)({
36
+ method: 'PUT',
37
+ url,
38
+ headers,
39
+ body: formattedBody,
40
+ resolveBody
41
+ });
35
42
  }),
36
- delete: (_a) => __awaiter(void 0, [_a], void 0, function* ({ scheme = constants_1.HTTPS_SCHEMA, host, path, url: currentUrl, headers = {} }) {
43
+ delete: (_a) => __awaiter(void 0, [_a], void 0, function* ({ scheme = constants_1.HTTPS_SCHEMA, host, path, url: currentUrl, headers = {}, resolveBody = true }) {
37
44
  const url = currentUrl ? currentUrl : `${scheme}://${host}/${path}`;
38
- return (0, utils_1.makeRequest)({ method: 'DELETE', url, headers });
45
+ return (0, utils_1.makeRequest)({ method: 'DELETE', url, headers, resolveBody });
39
46
  })
40
47
  });
41
48
  exports.default = Api;
package/dist/services/api/model.d.ts CHANGED
@@ -8,10 +8,12 @@ export interface MakeRequestParams {
8
8
  url: string;
9
9
  headers: Headers;
10
10
  body?: Body;
11
+ resolveBody?: boolean;
11
12
  }
12
13
  export interface GetParams {
13
14
  url: string;
14
15
  headers: Headers;
16
+ resolveBody?: boolean;
15
17
  }
16
18
  export interface PostParams {
17
19
  scheme?: string;
@@ -21,6 +23,7 @@ export interface PostParams {
21
23
  encodeBodyAsJSON?: boolean;
22
24
  body: Body;
23
25
  headers?: Headers;
26
+ resolveBody?: boolean;
24
27
  }
25
28
  export type PutParams = PostParams;
26
29
  export type DeleteParams = Omit<PostParams, 'body' | 'encodeBodyAsJSON'>;
package/dist/services/api/model.d.ts.map CHANGED
@@ -1 +1 @@
1
- {"version":3,"file":"model.d.ts","sourceRoot":"","sources":["../../../src/services/api/model.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,QAAQ,CAAA;AAEnC,KAAK,cAAc,GAAG,UAAU,CAAC,cAAc,CAAA;AAC/C,KAAK,YAAY,GAAG,cAAc,CAAC,QAAQ,CAAC,CAAA;AAC5C,KAAK,OAAO,GAAG,cAAc,CAAC,SAAS,CAAC,CAAA;AACxC,KAAK,IAAI,GAAG,cAAc,CAAC,MAAM,CAAC,CAAA;AAElC,MAAM,WAAW,iBAAiB;IAChC,MAAM,EAAE,YAAY,CAAA;IACpB,GAAG,EAAE,MAAM,CAAA;IACX,OAAO,EAAE,OAAO,CAAA;IAChB,IAAI,CAAC,EAAE,IAAI,CAAA;CACZ;AAED,MAAM,WAAW,SAAS;IACxB,GAAG,EAAE,MAAM,CAAA;IACX,OAAO,EAAE,OAAO,CAAA;CACjB;AAED,MAAM,WAAW,UAAU;IACzB,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,GAAG,CAAC,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,MAAM,CAAA;IACZ,gBAAgB,CAAC,EAAE,OAAO,CAAA;IAC1B,IAAI,EAAE,IAAI,CAAA;IACV,OAAO,CAAC,EAAE,OAAO,CAAA;CAClB;AAED,MAAM,MAAM,SAAS,GAAG,UAAU,CAAA;AAElC,MAAM,MAAM,YAAY,GAAG,IAAI,CAAC,UAAU,EAAE,MAAM,GAAG,kBAAkB,CAAC,CAAA;AAExE,MAAM,WAAW,KAAK;IACpB,OAAO,EAAE,MAAM,CAAA;IACf,UAAU,EAAE,UAAU,CAAC,YAAY,CAAC,YAAY,CAAC,CAAA;IACjD,OAAO,CAAC,EAAE,UAAU,CAAC,YAAY,CAAC,SAAS,CAAC,CAAA;CAC7C"}
1
+ {"version":3,"file":"model.d.ts","sourceRoot":"","sources":["../../../src/services/api/model.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,QAAQ,CAAA;AAEnC,KAAK,cAAc,GAAG,UAAU,CAAC,cAAc,CAAA;AAC/C,KAAK,YAAY,GAAG,cAAc,CAAC,QAAQ,CAAC,CAAA;AAC5C,KAAK,OAAO,GAAG,cAAc,CAAC,SAAS,CAAC,CAAA;AACxC,KAAK,IAAI,GAAG,cAAc,CAAC,MAAM,CAAC,CAAA;AAElC,MAAM,WAAW,iBAAiB;IAChC,MAAM,EAAE,YAAY,CAAA;IACpB,GAAG,EAAE,MAAM,CAAA;IACX,OAAO,EAAE,OAAO,CAAA;IAChB,IAAI,CAAC,EAAE,IAAI,CAAA;IACX,WAAW,CAAC,EAAE,OAAO,CAAA;CACtB;AAED,MAAM,WAAW,SAAS;IACxB,GAAG,EAAE,MAAM,CAAA;IACX,OAAO,EAAE,OAAO,CAAA;IAChB,WAAW,CAAC,EAAE,OAAO,CAAA;CACtB;AAED,MAAM,WAAW,UAAU;IACzB,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,GAAG,CAAC,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,MAAM,CAAA;IACZ,gBAAgB,CAAC,EAAE,OAAO,CAAA;IAC1B,IAAI,EAAE,IAAI,CAAA;IACV,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB,WAAW,CAAC,EAAE,OAAO,CAAA;CACtB;AAED,MAAM,MAAM,SAAS,GAAG,UAAU,CAAA;AAElC,MAAM,MAAM,YAAY,GAAG,IAAI,CAAC,UAAU,EAAE,MAAM,GAAG,kBAAkB,CAAC,CAAA;AAExE,MAAM,WAAW,KAAK;IACpB,OAAO,EAAE,MAAM,CAAA;IACf,UAAU,EAAE,UAAU,CAAC,YAAY,CAAC,YAAY,CAAC,CAAA;IACjD,OAAO,CAAC,EAAE,UAAU,CAAC,YAAY,CAAC,SAAS,CAAC,CAAA;CAC7C"}
package/dist/services/api/utils.d.ts CHANGED
@@ -6,11 +6,32 @@ import { MakeRequestParams } from './model';
6
6
  * @param headers -> request headers
7
7
  * @param body -> request body
8
8
  */
9
- export declare const makeRequest: <T = null>({ method, url, headers, body }: MakeRequestParams) => Promise<import("undici").Dispatcher.ResponseData<T> | {
9
+ export declare const makeRequest: <T = null>({ method, url, headers, body, resolveBody }: MakeRequestParams) => Promise<import("undici").Dispatcher.ResponseData<T> | {
10
10
  status: number;
11
11
  headers: import("undici/types/header").IncomingHttpHeaders;
12
12
  body: {
13
13
  message: string;
14
14
  };
15
+ } | {
16
+ body: {
17
+ text: () => string;
18
+ json: () => any;
19
+ arrayBuffer: () => ArrayBuffer;
20
+ bytes: () => Uint8Array<ArrayBuffer>;
21
+ };
22
+ status: number;
23
+ headers: import("undici/types/header").IncomingHttpHeaders;
24
+ } | {
25
+ body: {
26
+ text: () => string;
27
+ json: () => any;
28
+ arrayBuffer: () => ArrayBuffer;
29
+ bytes: () => Uint8Array<ArrayBuffer>;
30
+ };
31
+ statusCode: number;
32
+ headers: import("undici/types/header").IncomingHttpHeaders;
33
+ trailers: Record<string, string>;
34
+ opaque: T;
35
+ context: object;
15
36
  }>;
16
37
  //# sourceMappingURL=utils.d.ts.map
package/dist/services/api/utils.d.ts.map CHANGED
@@ -1 +1 @@
1
- {"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/services/api/utils.ts"],"names":[],"mappings":"AACA,OAAO,EAAS,iBAAiB,EAAE,MAAM,SAAS,CAAA;AAElD;;;;;;GAMG;AACH,eAAO,MAAM,WAAW,GAAU,CAAC,GAAG,IAAI,EAAE,gCAKzC,iBAAiB;;;;;;EAWnB,CAAA"}
1
+ {"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/services/api/utils.ts"],"names":[],"mappings":"AAEA,OAAO,EAAS,iBAAiB,EAAE,MAAM,SAAS,CAAA;AAgBlD;;;;;;GAMG;AACH,eAAO,MAAM,WAAW,GAAU,CAAC,GAAG,IAAI,EAAE,6CAMzC,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;EAgBnB,CAAA"}
package/dist/services/api/utils.js CHANGED
@@ -10,7 +10,18 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
10
10
  };
11
11
  Object.defineProperty(exports, "__esModule", { value: true });
12
12
  exports.makeRequest = void 0;
13
+ const consumers_1 = require("node:stream/consumers");
13
14
  const undici_1 = require("undici");
15
+ const createResolvedBody = (bodyBuffer) => {
16
+ const arrayBuffer = bodyBuffer.buffer.slice(bodyBuffer.byteOffset, bodyBuffer.byteOffset + bodyBuffer.byteLength);
17
+ const text = bodyBuffer.toString('utf8');
18
+ return {
19
+ text: () => text,
20
+ json: () => JSON.parse(text),
21
+ arrayBuffer: () => arrayBuffer,
22
+ bytes: () => new Uint8Array(arrayBuffer)
23
+ };
24
+ };
14
25
  /**
15
26
  * > Creates the http request
16
27
  * @param method -> the HTTP METHOD
@@ -18,17 +29,20 @@ const undici_1 = require("undici");
18
29
  * @param headers -> request headers
19
30
  * @param body -> request body
20
31
  */
21
- const makeRequest = (_a) => __awaiter(void 0, [_a], void 0, function* ({ method, url, headers, body }) {
32
+ const makeRequest = (_a) => __awaiter(void 0, [_a], void 0, function* ({ method, url, headers, body, resolveBody = true }) {
22
33
  try {
23
34
  const response = yield (0, undici_1.request)(url, {
24
35
  method,
25
36
  headers,
26
37
  body
27
38
  });
28
- return response;
39
+ if (!resolveBody)
40
+ return response;
41
+ const bodyBuffer = yield (0, consumers_1.buffer)(response.body);
42
+ return Object.assign(Object.assign({}, response), { body: createResolvedBody(bodyBuffer) });
29
43
  }
30
44
  catch (error) {
31
- return _handleError(error);
45
+ return _handleError(error, resolveBody);
32
46
  }
33
47
  });
34
48
  exports.makeRequest = makeRequest;
@@ -36,10 +50,15 @@ exports.makeRequest = makeRequest;
36
50
  * > Formats the request error
37
51
  * @param error -> the request error
38
52
  */
39
- const _handleError = (error) => __awaiter(void 0, void 0, void 0, function* () {
40
- return {
53
+ const _handleError = (error, resolveBody) => __awaiter(void 0, void 0, void 0, function* () {
54
+ const payload = { message: error.message };
55
+ const response = {
41
56
  status: error.statusCode || 500,
42
57
  headers: error.headers || {},
43
- body: { message: error.message }
58
+ body: payload
44
59
  };
60
+ if (!resolveBody)
61
+ return response;
62
+ const bodyBuffer = Buffer.from(JSON.stringify(payload), 'utf8');
63
+ return Object.assign(Object.assign({}, response), { body: createResolvedBody(bodyBuffer) });
45
64
  });
package/dist/services/index.d.ts CHANGED
@@ -1,33 +1,117 @@
1
1
  export declare const services: {
2
2
  api: () => {
3
- get: <T = null>({ url, headers }: import("./api/model").GetParams) => Promise<{
3
+ get: <T = null>({ url, headers, resolveBody }: import("./api/model").GetParams) => Promise<{
4
4
  status: number;
5
5
  headers: import("undici/types/header").IncomingHttpHeaders;
6
6
  body: {
7
7
  message: string;
8
8
  };
9
- } | import("undici").Dispatcher.ResponseData<T>>;
10
- post: <T = null>({ scheme, host, path, url: currentUrl, headers, body, encodeBodyAsJSON }: import("./api/model").PostParams) => Promise<{
9
+ } | {
10
+ body: {
11
+ text: () => string;
12
+ json: () => any;
13
+ arrayBuffer: () => ArrayBuffer;
14
+ bytes: () => Uint8Array<ArrayBuffer>;
15
+ };
16
+ status: number;
17
+ headers: import("undici/types/header").IncomingHttpHeaders;
18
+ } | import("undici").Dispatcher.ResponseData<T> | {
19
+ body: {
20
+ text: () => string;
21
+ json: () => any;
22
+ arrayBuffer: () => ArrayBuffer;
23
+ bytes: () => Uint8Array<ArrayBuffer>;
24
+ };
25
+ statusCode: number;
26
+ headers: import("undici/types/header").IncomingHttpHeaders;
27
+ trailers: Record<string, string>;
28
+ opaque: T;
29
+ context: object;
30
+ }>;
31
+ post: <T = null>({ scheme, host, path, url: currentUrl, headers, body, encodeBodyAsJSON, resolveBody }: import("./api/model").PostParams) => Promise<{
11
32
  status: number;
12
33
  headers: import("undici/types/header").IncomingHttpHeaders;
13
34
  body: {
14
35
  message: string;
15
36
  };
16
- } | import("undici").Dispatcher.ResponseData<T>>;
17
- put: <T = null>({ scheme, host, path, url: currentUrl, headers, body, encodeBodyAsJSON }: import("./api/model").PutParams) => Promise<{
37
+ } | {
38
+ body: {
39
+ text: () => string;
40
+ json: () => any;
41
+ arrayBuffer: () => ArrayBuffer;
42
+ bytes: () => Uint8Array<ArrayBuffer>;
43
+ };
44
+ status: number;
45
+ headers: import("undici/types/header").IncomingHttpHeaders;
46
+ } | import("undici").Dispatcher.ResponseData<T> | {
47
+ body: {
48
+ text: () => string;
49
+ json: () => any;
50
+ arrayBuffer: () => ArrayBuffer;
51
+ bytes: () => Uint8Array<ArrayBuffer>;
52
+ };
53
+ statusCode: number;
54
+ headers: import("undici/types/header").IncomingHttpHeaders;
55
+ trailers: Record<string, string>;
56
+ opaque: T;
57
+ context: object;
58
+ }>;
59
+ put: <T = null>({ scheme, host, path, url: currentUrl, headers, body, encodeBodyAsJSON, resolveBody }: import("./api/model").PutParams) => Promise<{
18
60
  status: number;
19
61
  headers: import("undici/types/header").IncomingHttpHeaders;
20
62
  body: {
21
63
  message: string;
22
64
  };
23
- } | import("undici").Dispatcher.ResponseData<T>>;
24
- delete: <T = null>({ scheme, host, path, url: currentUrl, headers }: import("./api/model").DeleteParams) => Promise<{
65
+ } | {
66
+ body: {
67
+ text: () => string;
68
+ json: () => any;
69
+ arrayBuffer: () => ArrayBuffer;
70
+ bytes: () => Uint8Array<ArrayBuffer>;
71
+ };
72
+ status: number;
73
+ headers: import("undici/types/header").IncomingHttpHeaders;
74
+ } | import("undici").Dispatcher.ResponseData<T> | {
75
+ body: {
76
+ text: () => string;
77
+ json: () => any;
78
+ arrayBuffer: () => ArrayBuffer;
79
+ bytes: () => Uint8Array<ArrayBuffer>;
80
+ };
81
+ statusCode: number;
82
+ headers: import("undici/types/header").IncomingHttpHeaders;
83
+ trailers: Record<string, string>;
84
+ opaque: T;
85
+ context: object;
86
+ }>;
87
+ delete: <T = null>({ scheme, host, path, url: currentUrl, headers, resolveBody }: import("./api/model").DeleteParams) => Promise<{
25
88
  status: number;
26
89
  headers: import("undici/types/header").IncomingHttpHeaders;
27
90
  body: {
28
91
  message: string;
29
92
  };
30
- } | import("undici").Dispatcher.ResponseData<T>>;
93
+ } | {
94
+ body: {
95
+ text: () => string;
96
+ json: () => any;
97
+ arrayBuffer: () => ArrayBuffer;
98
+ bytes: () => Uint8Array<ArrayBuffer>;
99
+ };
100
+ status: number;
101
+ headers: import("undici/types/header").IncomingHttpHeaders;
102
+ } | import("undici").Dispatcher.ResponseData<T> | {
103
+ body: {
104
+ text: () => string;
105
+ json: () => any;
106
+ arrayBuffer: () => ArrayBuffer;
107
+ bytes: () => Uint8Array<ArrayBuffer>;
108
+ };
109
+ statusCode: number;
110
+ headers: import("undici/types/header").IncomingHttpHeaders;
111
+ trailers: Record<string, string>;
112
+ opaque: T;
113
+ context: object;
114
+ }>;
31
115
  };
32
116
  aws: () => {
33
117
  lambda: (region: string) => import("aws-sdk").Lambda & {
package/dist/services/index.d.ts.map CHANGED
@@ -1 +1 @@
1
- {"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/services/index.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAMqT,GAAc;;;;;;;CADvV,CAAA"}
1
+ {"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/services/index.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAMqT,GAAc;;;;;;;CADvV,CAAA"}
package/dist/utils/context/helpers.d.ts CHANGED
@@ -13,6 +13,7 @@ import { GenerateContextDataParams } from './interface';
13
13
  */
14
14
  export declare const generateContextData: ({ user, services, app, rules, currentFunction, functionsList, GenerateContext, request }: GenerateContextDataParams) => {
15
15
  BSON: typeof mongodb.BSON;
16
+ Buffer: BufferConstructor;
16
17
  console: {
17
18
  log: (...args: Arguments) => void;
18
19
  error: (...args: Arguments) => void;
@@ -41,34 +42,118 @@ export declare const generateContextData: ({ user, services, app, rules, current
41
42
  collection: (collName: string) => ReturnType<import("../../services/mongodb-atlas/model").GetOperatorsFunction>;
42
43
  };
43
44
  } | {
44
- get: <T = null>({ url, headers }: import("../../services/api/model").GetParams) => Promise<{
45
+ get: <T = null>({ url, headers, resolveBody }: import("../../services/api/model").GetParams) => Promise<{
45
46
  status: number;
46
47
  headers: import("undici/types/header").IncomingHttpHeaders;
47
48
  body: {
48
49
  message: string;
49
50
  };
50
- } | import("undici").Dispatcher.ResponseData<T>>;
51
- post: <T = null>({ scheme, host, path, url: currentUrl, headers, body, encodeBodyAsJSON }: import("../../services/api/model").PostParams) => Promise<{
51
+ } | {
52
+ body: {
53
+ text: () => string;
54
+ json: () => any;
55
+ arrayBuffer: () => ArrayBuffer;
56
+ bytes: () => Uint8Array<ArrayBuffer>;
57
+ };
58
+ status: number;
59
+ headers: import("undici/types/header").IncomingHttpHeaders;
60
+ } | import("undici").Dispatcher.ResponseData<T> | {
61
+ body: {
62
+ text: () => string;
63
+ json: () => any;
64
+ arrayBuffer: () => ArrayBuffer;
65
+ bytes: () => Uint8Array<ArrayBuffer>;
66
+ };
67
+ statusCode: number;
68
+ headers: import("undici/types/header").IncomingHttpHeaders;
69
+ trailers: Record<string, string>;
70
+ opaque: T;
71
+ context: object;
72
+ }>;
73
+ post: <T = null>({ scheme, host, path, url: currentUrl, headers, body, encodeBodyAsJSON, resolveBody }: import("../../services/api/model").PostParams) => Promise<{
52
74
  status: number;
53
75
  headers: import("undici/types/header").IncomingHttpHeaders;
54
76
  body: {
55
77
  message: string;
56
78
  };
57
- } | import("undici").Dispatcher.ResponseData<T>>;
58
- put: <T = null>({ scheme, host, path, url: currentUrl, headers, body, encodeBodyAsJSON }: import("../../services/api/model").PutParams) => Promise<{
79
+ } | {
80
+ body: {
81
+ text: () => string;
82
+ json: () => any;
83
+ arrayBuffer: () => ArrayBuffer;
84
+ bytes: () => Uint8Array<ArrayBuffer>;
85
+ };
86
+ status: number;
87
+ headers: import("undici/types/header").IncomingHttpHeaders;
88
+ } | import("undici").Dispatcher.ResponseData<T> | {
89
+ body: {
90
+ text: () => string;
91
+ json: () => any;
92
+ arrayBuffer: () => ArrayBuffer;
93
+ bytes: () => Uint8Array<ArrayBuffer>;
94
+ };
95
+ statusCode: number;
96
+ headers: import("undici/types/header").IncomingHttpHeaders;
97
+ trailers: Record<string, string>;
98
+ opaque: T;
99
+ context: object;
100
+ }>;
101
+ put: <T = null>({ scheme, host, path, url: currentUrl, headers, body, encodeBodyAsJSON, resolveBody }: import("../../services/api/model").PutParams) => Promise<{
59
102
  status: number;
60
103
  headers: import("undici/types/header").IncomingHttpHeaders;
61
104
  body: {
62
105
  message: string;
63
106
  };
64
- } | import("undici").Dispatcher.ResponseData<T>>;
65
- delete: <T = null>({ scheme, host, path, url: currentUrl, headers }: import("../../services/api/model").DeleteParams) => Promise<{
107
+ } | {
108
+ body: {
109
+ text: () => string;
110
+ json: () => any;
111
+ arrayBuffer: () => ArrayBuffer;
112
+ bytes: () => Uint8Array<ArrayBuffer>;
113
+ };
114
+ status: number;
115
+ headers: import("undici/types/header").IncomingHttpHeaders;
116
+ } | import("undici").Dispatcher.ResponseData<T> | {
117
+ body: {
118
+ text: () => string;
119
+ json: () => any;
120
+ arrayBuffer: () => ArrayBuffer;
121
+ bytes: () => Uint8Array<ArrayBuffer>;
122
+ };
123
+ statusCode: number;
124
+ headers: import("undici/types/header").IncomingHttpHeaders;
125
+ trailers: Record<string, string>;
126
+ opaque: T;
127
+ context: object;
128
+ }>;
129
+ delete: <T = null>({ scheme, host, path, url: currentUrl, headers, resolveBody }: import("../../services/api/model").DeleteParams) => Promise<{
66
130
  status: number;
67
131
  headers: import("undici/types/header").IncomingHttpHeaders;
68
132
  body: {
69
133
  message: string;
70
134
  };
71
- } | import("undici").Dispatcher.ResponseData<T>>;
135
+ } | {
136
+ body: {
137
+ text: () => string;
138
+ json: () => any;
139
+ arrayBuffer: () => ArrayBuffer;
140
+ bytes: () => Uint8Array<ArrayBuffer>;
141
+ };
142
+ status: number;
143
+ headers: import("undici/types/header").IncomingHttpHeaders;
144
+ } | import("undici").Dispatcher.ResponseData<T> | {
145
+ body: {
146
+ text: () => string;
147
+ json: () => any;
148
+ arrayBuffer: () => ArrayBuffer;
149
+ bytes: () => Uint8Array<ArrayBuffer>;
150
+ };
151
+ statusCode: number;
152
+ headers: import("undici/types/header").IncomingHttpHeaders;
153
+ trailers: Record<string, string>;
154
+ opaque: T;
155
+ context: object;
156
+ }>;
72
157
  } | {
73
158
  lambda: (region: string) => import("aws-sdk").Lambda & {
74
159
  Invoke: (...args: Parameters<import("aws-sdk").Lambda["invoke"]>) => Promise<import("aws-sdk/lib/request").PromiseResult<import("aws-sdk/clients/lambda").InvocationResponse, import("aws-sdk").AWSError>>;
@@ -81,6 +166,262 @@ export declare const generateContextData: ({ user, services, app, rules, current
81
166
  };
82
167
  } | undefined;
83
168
  };
169
+ http: {
170
+ db: (dbName: string) => {
171
+ collection: (collName: string) => ReturnType<import("../../services/mongodb-atlas/model").GetOperatorsFunction>;
172
+ };
173
+ } | {
174
+ get: <T = null>({ url, headers, resolveBody }: import("../../services/api/model").GetParams) => Promise<{
175
+ status: number;
176
+ headers: import("undici/types/header").IncomingHttpHeaders;
177
+ body: {
178
+ message: string;
179
+ };
180
+ } | {
181
+ body: {
182
+ text: () => string;
183
+ json: () => any;
184
+ arrayBuffer: () => ArrayBuffer;
185
+ bytes: () => Uint8Array<ArrayBuffer>;
186
+ };
187
+ status: number;
188
+ headers: import("undici/types/header").IncomingHttpHeaders;
189
+ } | import("undici").Dispatcher.ResponseData<T> | {
190
+ body: {
191
+ text: () => string;
192
+ json: () => any;
193
+ arrayBuffer: () => ArrayBuffer;
194
+ bytes: () => Uint8Array<ArrayBuffer>;
195
+ };
196
+ statusCode: number;
197
+ headers: import("undici/types/header").IncomingHttpHeaders;
198
+ trailers: Record<string, string>;
199
+ opaque: T;
200
+ context: object;
201
+ }>;
202
+ post: <T = null>({ scheme, host, path, url: currentUrl, headers, body, encodeBodyAsJSON, resolveBody }: import("../../services/api/model").PostParams) => Promise<{
203
+ status: number;
204
+ headers: import("undici/types/header").IncomingHttpHeaders;
205
+ body: {
206
+ message: string;
207
+ };
208
+ } | {
209
+ body: {
210
+ text: () => string;
211
+ json: () => any;
212
+ arrayBuffer: () => ArrayBuffer;
213
+ bytes: () => Uint8Array<ArrayBuffer>;
214
+ };
215
+ status: number;
216
+ headers: import("undici/types/header").IncomingHttpHeaders;
217
+ } | import("undici").Dispatcher.ResponseData<T> | {
218
+ body: {
219
+ text: () => string;
220
+ json: () => any;
221
+ arrayBuffer: () => ArrayBuffer;
222
+ bytes: () => Uint8Array<ArrayBuffer>;
223
+ };
224
+ statusCode: number;
225
+ headers: import("undici/types/header").IncomingHttpHeaders;
226
+ trailers: Record<string, string>;
227
+ opaque: T;
228
+ context: object;
229
+ }>;
230
+ put: <T = null>({ scheme, host, path, url: currentUrl, headers, body, encodeBodyAsJSON, resolveBody }: import("../../services/api/model").PutParams) => Promise<{
231
+ status: number;
232
+ headers: import("undici/types/header").IncomingHttpHeaders;
233
+ body: {
234
+ message: string;
235
+ };
236
+ } | {
237
+ body: {
238
+ text: () => string;
239
+ json: () => any;
240
+ arrayBuffer: () => ArrayBuffer;
241
+ bytes: () => Uint8Array<ArrayBuffer>;
242
+ };
243
+ status: number;
244
+ headers: import("undici/types/header").IncomingHttpHeaders;
245
+ } | import("undici").Dispatcher.ResponseData<T> | {
246
+ body: {
247
+ text: () => string;
248
+ json: () => any;
249
+ arrayBuffer: () => ArrayBuffer;
250
+ bytes: () => Uint8Array<ArrayBuffer>;
251
+ };
252
+ statusCode: number;
253
+ headers: import("undici/types/header").IncomingHttpHeaders;
254
+ trailers: Record<string, string>;
255
+ opaque: T;
256
+ context: object;
257
+ }>;
258
+ delete: <T = null>({ scheme, host, path, url: currentUrl, headers, resolveBody }: import("../../services/api/model").DeleteParams) => Promise<{
259
+ status: number;
260
+ headers: import("undici/types/header").IncomingHttpHeaders;
261
+ body: {
262
+ message: string;
263
+ };
264
+ } | {
265
+ body: {
266
+ text: () => string;
267
+ json: () => any;
268
+ arrayBuffer: () => ArrayBuffer;
269
+ bytes: () => Uint8Array<ArrayBuffer>;
270
+ };
271
+ status: number;
272
+ headers: import("undici/types/header").IncomingHttpHeaders;
273
+ } | import("undici").Dispatcher.ResponseData<T> | {
274
+ body: {
275
+ text: () => string;
276
+ json: () => any;
277
+ arrayBuffer: () => ArrayBuffer;
278
+ bytes: () => Uint8Array<ArrayBuffer>;
279
+ };
280
+ statusCode: number;
281
+ headers: import("undici/types/header").IncomingHttpHeaders;
282
+ trailers: Record<string, string>;
283
+ opaque: T;
284
+ context: object;
285
+ }>;
286
+ } | {
287
+ lambda: (region: string) => import("aws-sdk").Lambda & {
288
+ Invoke: (...args: Parameters<import("aws-sdk").Lambda["invoke"]>) => Promise<import("aws-sdk/lib/request").PromiseResult<import("aws-sdk/clients/lambda").InvocationResponse, import("aws-sdk").AWSError>>;
289
+ InvokeAsync: import("aws-sdk").Lambda["invokeAsync"];
290
+ };
291
+ s3: (region: string) => import("aws-sdk").S3;
292
+ } | {
293
+ emailPasswordAuth: {
294
+ registerUser: ReturnType<import("../../shared/models/handleUserRegistration.model").HandleUserRegistration>;
295
+ };
296
+ } | undefined;
297
+ https: {
298
+ db: (dbName: string) => {
299
+ collection: (collName: string) => ReturnType<import("../../services/mongodb-atlas/model").GetOperatorsFunction>;
300
+ };
301
+ } | {
302
+ get: <T = null>({ url, headers, resolveBody }: import("../../services/api/model").GetParams) => Promise<{
303
+ status: number;
304
+ headers: import("undici/types/header").IncomingHttpHeaders;
305
+ body: {
306
+ message: string;
307
+ };
308
+ } | {
309
+ body: {
310
+ text: () => string;
311
+ json: () => any;
312
+ arrayBuffer: () => ArrayBuffer;
313
+ bytes: () => Uint8Array<ArrayBuffer>;
314
+ };
315
+ status: number;
316
+ headers: import("undici/types/header").IncomingHttpHeaders;
317
+ } | import("undici").Dispatcher.ResponseData<T> | {
318
+ body: {
319
+ text: () => string;
320
+ json: () => any;
321
+ arrayBuffer: () => ArrayBuffer;
322
+ bytes: () => Uint8Array<ArrayBuffer>;
323
+ };
324
+ statusCode: number;
325
+ headers: import("undici/types/header").IncomingHttpHeaders;
326
+ trailers: Record<string, string>;
327
+ opaque: T;
328
+ context: object;
329
+ }>;
330
+ post: <T = null>({ scheme, host, path, url: currentUrl, headers, body, encodeBodyAsJSON, resolveBody }: import("../../services/api/model").PostParams) => Promise<{
331
+ status: number;
332
+ headers: import("undici/types/header").IncomingHttpHeaders;
333
+ body: {
334
+ message: string;
335
+ };
336
+ } | {
337
+ body: {
338
+ text: () => string;
339
+ json: () => any;
340
+ arrayBuffer: () => ArrayBuffer;
341
+ bytes: () => Uint8Array<ArrayBuffer>;
342
+ };
343
+ status: number;
344
+ headers: import("undici/types/header").IncomingHttpHeaders;
345
+ } | import("undici").Dispatcher.ResponseData<T> | {
346
+ body: {
347
+ text: () => string;
348
+ json: () => any;
349
+ arrayBuffer: () => ArrayBuffer;
350
+ bytes: () => Uint8Array<ArrayBuffer>;
351
+ };
352
+ statusCode: number;
353
+ headers: import("undici/types/header").IncomingHttpHeaders;
354
+ trailers: Record<string, string>;
355
+ opaque: T;
356
+ context: object;
357
+ }>;
358
+ put: <T = null>({ scheme, host, path, url: currentUrl, headers, body, encodeBodyAsJSON, resolveBody }: import("../../services/api/model").PutParams) => Promise<{
359
+ status: number;
360
+ headers: import("undici/types/header").IncomingHttpHeaders;
361
+ body: {
362
+ message: string;
363
+ };
364
+ } | {
365
+ body: {
366
+ text: () => string;
367
+ json: () => any;
368
+ arrayBuffer: () => ArrayBuffer;
369
+ bytes: () => Uint8Array<ArrayBuffer>;
370
+ };
371
+ status: number;
372
+ headers: import("undici/types/header").IncomingHttpHeaders;
373
+ } | import("undici").Dispatcher.ResponseData<T> | {
374
+ body: {
375
+ text: () => string;
376
+ json: () => any;
377
+ arrayBuffer: () => ArrayBuffer;
378
+ bytes: () => Uint8Array<ArrayBuffer>;
379
+ };
380
+ statusCode: number;
381
+ headers: import("undici/types/header").IncomingHttpHeaders;
382
+ trailers: Record<string, string>;
383
+ opaque: T;
384
+ context: object;
385
+ }>;
386
+ delete: <T = null>({ scheme, host, path, url: currentUrl, headers, resolveBody }: import("../../services/api/model").DeleteParams) => Promise<{
387
+ status: number;
388
+ headers: import("undici/types/header").IncomingHttpHeaders;
389
+ body: {
390
+ message: string;
391
+ };
392
+ } | {
393
+ body: {
394
+ text: () => string;
395
+ json: () => any;
396
+ arrayBuffer: () => ArrayBuffer;
397
+ bytes: () => Uint8Array<ArrayBuffer>;
398
+ };
399
+ status: number;
400
+ headers: import("undici/types/header").IncomingHttpHeaders;
401
+ } | import("undici").Dispatcher.ResponseData<T> | {
402
+ body: {
403
+ text: () => string;
404
+ json: () => any;
405
+ arrayBuffer: () => ArrayBuffer;
406
+ bytes: () => Uint8Array<ArrayBuffer>;
407
+ };
408
+ statusCode: number;
409
+ headers: import("undici/types/header").IncomingHttpHeaders;
410
+ trailers: Record<string, string>;
411
+ opaque: T;
412
+ context: object;
413
+ }>;
414
+ } | {
415
+ lambda: (region: string) => import("aws-sdk").Lambda & {
416
+ Invoke: (...args: Parameters<import("aws-sdk").Lambda["invoke"]>) => Promise<import("aws-sdk/lib/request").PromiseResult<import("aws-sdk/clients/lambda").InvocationResponse, import("aws-sdk").AWSError>>;
417
+ InvokeAsync: import("aws-sdk").Lambda["invokeAsync"];
418
+ };
419
+ s3: (region: string) => import("aws-sdk").S3;
420
+ } | {
421
+ emailPasswordAuth: {
422
+ registerUser: ReturnType<import("../../shared/models/handleUserRegistration.model").HandleUserRegistration>;
423
+ };
424
+ } | undefined;
84
425
  functions: {
85
426
  execute: (name: keyof typeof functionsList, ...args: Arguments) => Promise<unknown>;
86
427
  };
package/dist/utils/context/helpers.d.ts.map CHANGED
@@ -1 +1 @@
1
- {"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../../../src/utils/context/helpers.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAA;AAC1C,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAA;AAE3C,OAAO,EAAE,yBAAyB,EAAE,MAAM,aAAa,CAAA;AAEvD;;;;;;;;;GASG;AACH,eAAO,MAAM,mBAAmB,GAAI,0FASjC,yBAAyB;;;uBAGT,SAAS;yBAGP,SAAS;;;;;;;;;;;;;;;;;;uBAcb,MAAM;;;+BAGE,MAAM,OAAO,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6BAlCG,GAE3C;;;;;;;;;;;4BAiDgB,MAAM,OAAO,aAAa,WAAW,SAAS;;;CAclE,CAAA"}
1
+ {"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../../../src/utils/context/helpers.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAA;AAC1C,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAA;AAE3C,OAAO,EAAE,yBAAyB,EAAE,MAAM,aAAa,CAAA;AAEvD;;;;;;;;;GASG;AACH,eAAO,MAAM,mBAAmB,GAAI,0FASjC,yBAAyB;;;;uBAqBP,SAAS;yBAGP,SAAS;;;;;;;;;;;;;;;;;;uBAcb,MAAM;;;+BArCU,MAAM,OAAO,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6BAZP,GAE3C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yBAF2C,GAE3C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yBAF2C,GAE3C;;;;;;;;;;4BAuDkB,MAAM,OAAO,aAAa,WAAW,SAAS;;;CAerE,CAAA"}
package/dist/utils/context/helpers.js CHANGED
@@ -12,53 +12,59 @@ const mongodb_1 = require("@fastify/mongodb");
12
12
  * @param currentFunction -> the function's name that should be called
13
13
  * @param functionsList -> the list of all functions
14
14
  */
15
- const generateContextData = ({ user, services, app, rules, currentFunction, functionsList, GenerateContext, request }) => ({
16
- BSON: mongodb_1.mongodb.BSON,
17
- console: {
18
- log: (...args) => {
19
- console.log(...args);
20
- },
21
- error: (...args) => {
22
- console.error(...args);
15
+ const generateContextData = ({ user, services, app, rules, currentFunction, functionsList, GenerateContext, request }) => {
16
+ const getService = (serviceName) => {
17
+ try {
18
+ return services[serviceName](app, {
19
+ rules,
20
+ user,
21
+ run_as_system: currentFunction.run_as_system
22
+ });
23
23
  }
24
- },
25
- context: {
26
- request: Object.assign(Object.assign({}, request), { remoteIPAddress: request === null || request === void 0 ? void 0 : request.ip }),
27
- user,
28
- environment: {
29
- tag: process.env.NODE_ENV
30
- },
31
- values: {
32
- get: (key) => process.env[key]
24
+ catch (error) {
25
+ console.error('Something went wrong while generating context function', serviceName, error);
26
+ }
27
+ };
28
+ return {
29
+ BSON: mongodb_1.mongodb.BSON,
30
+ Buffer,
31
+ console: {
32
+ log: (...args) => {
33
+ console.log(...args);
34
+ },
35
+ error: (...args) => {
36
+ console.error(...args);
37
+ }
33
38
  },
34
- services: {
35
- get: (serviceName) => {
36
- try {
37
- return services[serviceName](app, {
39
+ context: {
40
+ request: Object.assign(Object.assign({}, request), { remoteIPAddress: request === null || request === void 0 ? void 0 : request.ip }),
41
+ user,
42
+ environment: {
43
+ tag: process.env.NODE_ENV
44
+ },
45
+ values: {
46
+ get: (key) => process.env[key]
47
+ },
48
+ services: {
49
+ get: getService
50
+ },
51
+ http: getService('api'),
52
+ https: getService('api'),
53
+ functions: {
54
+ execute: (name, ...args) => {
55
+ const currentFunction = functionsList[name];
56
+ return GenerateContext({
57
+ args,
58
+ app,
38
59
  rules,
39
60
  user,
40
- run_as_system: currentFunction.run_as_system
61
+ currentFunction,
62
+ functionsList,
63
+ services
41
64
  });
42
65
  }
43
- catch (error) {
44
- console.error('Something went wrong while generating context function', serviceName, error);
45
- }
46
- }
47
- },
48
- functions: {
49
- execute: (name, ...args) => {
50
- const currentFunction = functionsList[name];
51
- return GenerateContext({
52
- args,
53
- app,
54
- rules,
55
- user,
56
- currentFunction,
57
- functionsList,
58
- services
59
- });
60
66
  }
61
67
  }
62
- }
63
- });
68
+ };
69
+ };
64
70
  exports.generateContextData = generateContextData;
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "@flowerforce/flowerbase",
3
- "version": "1.3.1-beta.0",
3
+ "version": "1.3.1-beta.2",
4
4
  "description": "",
5
5
  "main": "dist/index.js",
6
6
  "types": "dist/index.d.ts",
@@ -29,7 +29,6 @@
29
29
  "bson": "^6.8.0",
30
30
  "dotenv": "^16.4.7",
31
31
  "fastify": "^5.0.0",
32
- "fastify-mongoose-driver": "^3.2.0",
33
32
  "fastify-plugin": "^5.0.1",
34
33
  "fastify-raw-body": "^5.0.0",
35
34
  "lodash": "^4.17.21",
package/src/features/functions/controller.ts CHANGED
@@ -1,6 +1,6 @@
1
1
  import { ObjectId } from 'bson'
2
- import { ChangeStream, Document } from 'mongodb';
3
2
  import type { FastifyRequest } from 'fastify'
3
+ import { ChangeStream, Document } from 'mongodb';
4
4
  import { services } from '../../services'
5
5
  import { StateManager } from '../../state'
6
6
  import { GenerateContext } from '../../utils/context'
package/src/services/api/index.ts CHANGED
@@ -6,8 +6,8 @@ import { makeRequest } from './utils'
6
6
  * > This service is the Api Client that can be imported from the context
7
7
  */
8
8
  const Api = () => ({
9
- get: async <T = null>({ url, headers = {} }: GetParams) => {
10
- return makeRequest<T>({ method: 'GET', url, headers })
9
+ get: async <T = null>({ url, headers = {}, resolveBody = true }: GetParams) => {
10
+ return makeRequest<T>({ method: 'GET', url, headers, resolveBody })
11
11
  },
12
12
  post: async <T = null>({
13
13
  scheme = HTTPS_SCHEMA,
@@ -16,7 +16,8 @@ const Api = () => ({
16
16
  url: currentUrl,
17
17
  headers = {},
18
18
  body,
19
- encodeBodyAsJSON = false
19
+ encodeBodyAsJSON = false,
20
+ resolveBody = true
20
21
  }: PostParams) => {
21
22
  const formattedBody = encodeBodyAsJSON ? JSON.stringify(body) : body
22
23
  const url = currentUrl ? currentUrl : `${scheme}://${host}/${path}`
@@ -24,7 +25,8 @@ const Api = () => ({
24
25
  method: 'POST',
25
26
  url,
26
27
  headers: { 'Content-Type': 'application/json', ...headers },
27
- body: formattedBody
28
+ body: formattedBody,
29
+ resolveBody
28
30
  })
29
31
  },
30
32
  put: async <T = null>({
@@ -34,21 +36,29 @@ const Api = () => ({
34
36
  url: currentUrl,
35
37
  headers = {},
36
38
  body,
37
- encodeBodyAsJSON = false
39
+ encodeBodyAsJSON = false,
40
+ resolveBody = true
38
41
  }: PutParams) => {
39
42
  const formattedBody = encodeBodyAsJSON ? JSON.stringify(body) : body
40
43
  const url = currentUrl ? currentUrl : `${scheme}://${host}/${path}`
41
- return makeRequest<T>({ method: 'PUT', url, headers, body: formattedBody })
44
+ return makeRequest<T>({
45
+ method: 'PUT',
46
+ url,
47
+ headers,
48
+ body: formattedBody,
49
+ resolveBody
50
+ })
42
51
  },
43
52
  delete: async <T = null>({
44
53
  scheme = HTTPS_SCHEMA,
45
54
  host,
46
55
  path,
47
56
  url: currentUrl,
48
- headers = {}
57
+ headers = {},
58
+ resolveBody = true
49
59
  }: DeleteParams) => {
50
60
  const url = currentUrl ? currentUrl : `${scheme}://${host}/${path}`
51
- return makeRequest<T>({ method: 'DELETE', url, headers })
61
+ return makeRequest<T>({ method: 'DELETE', url, headers, resolveBody })
52
62
  }
53
63
  })
54
64
 
package/src/services/api/model.ts CHANGED
@@ -10,11 +10,13 @@ export interface MakeRequestParams {
10
10
  url: string
11
11
  headers: Headers
12
12
  body?: Body
13
+ resolveBody?: boolean
13
14
  }
14
15
 
15
16
  export interface GetParams {
16
17
  url: string
17
18
  headers: Headers
19
+ resolveBody?: boolean
18
20
  }
19
21
 
20
22
  export interface PostParams {
@@ -25,6 +27,7 @@ export interface PostParams {
25
27
  encodeBodyAsJSON?: boolean
26
28
  body: Body
27
29
  headers?: Headers
30
+ resolveBody?: boolean
28
31
  }
29
32
 
30
33
  export type PutParams = PostParams
package/src/services/api/utils.ts CHANGED
@@ -1,6 +1,21 @@
1
+ import { buffer as consumeBuffer } from 'node:stream/consumers'
1
2
  import { request } from 'undici'
2
3
  import { Error, MakeRequestParams } from './model'
3
4
 
5
+ const createResolvedBody = (bodyBuffer: Buffer) => {
6
+ const arrayBuffer = bodyBuffer.buffer.slice(
7
+ bodyBuffer.byteOffset,
8
+ bodyBuffer.byteOffset + bodyBuffer.byteLength
9
+ )
10
+ const text = bodyBuffer.toString('utf8')
11
+ return {
12
+ text: () => text,
13
+ json: () => JSON.parse(text),
14
+ arrayBuffer: () => arrayBuffer,
15
+ bytes: () => new Uint8Array(arrayBuffer)
16
+ }
17
+ }
18
+
4
19
  /**
5
20
  * > Creates the http request
6
21
  * @param method -> the HTTP METHOD
@@ -12,7 +27,8 @@ export const makeRequest = async <T = null>({
12
27
  method,
13
28
  url,
14
29
  headers,
15
- body
30
+ body,
31
+ resolveBody = true
16
32
  }: MakeRequestParams) => {
17
33
  try {
18
34
  const response = await request<T>(url, {
@@ -20,9 +36,14 @@ export const makeRequest = async <T = null>({
20
36
  headers,
21
37
  body
22
38
  })
23
- return response
39
+ if (!resolveBody) return response
40
+ const bodyBuffer = await consumeBuffer(response.body)
41
+ return {
42
+ ...response,
43
+ body: createResolvedBody(bodyBuffer)
44
+ }
24
45
  } catch (error) {
25
- return _handleError(error as Error)
46
+ return _handleError(error as Error, resolveBody)
26
47
  }
27
48
  }
28
49
 
@@ -30,10 +51,14 @@ export const makeRequest = async <T = null>({
30
51
  * > Formats the request error
31
52
  * @param error -> the request error
32
53
  */
33
- const _handleError = async (error: Error) => {
34
- return {
54
+ const _handleError = async (error: Error, resolveBody: boolean) => {
55
+ const payload = { message: error.message }
56
+ const response = {
35
57
  status: error.statusCode || 500,
36
58
  headers: error.headers || {},
37
- body: { message: error.message }
59
+ body: payload
38
60
  }
61
+ if (!resolveBody) return response
62
+ const bodyBuffer = Buffer.from(JSON.stringify(payload), 'utf8')
63
+ return { ...response, body: createResolvedBody(bodyBuffer) }
39
64
  }
package/src/utils/context/helpers.ts CHANGED
@@ -22,58 +22,65 @@ export const generateContextData = ({
22
22
  functionsList,
23
23
  GenerateContext,
24
24
  request
25
- }: GenerateContextDataParams) => ({
26
- BSON: mongodb.BSON,
27
- console: {
28
- log: (...args: Arguments) => {
29
- console.log(...args)
30
- },
31
- error: (...args: Arguments) => {
32
- console.error(...args)
25
+ }: GenerateContextDataParams) => {
26
+ const getService = (serviceName: keyof typeof services) => {
27
+ try {
28
+ return services[serviceName](app, {
29
+ rules,
30
+ user,
31
+ run_as_system: currentFunction.run_as_system
32
+ })
33
+ } catch (error) {
34
+ console.error(
35
+ 'Something went wrong while generating context function',
36
+ serviceName,
37
+ error
38
+ )
33
39
  }
34
- },
35
- context: {
36
- request: {
37
- ...request,
38
- remoteIPAddress: request?.ip
39
- },
40
- user,
41
- environment: {
42
- tag: process.env.NODE_ENV
43
- },
44
- values: {
45
- get: (key: string) => process.env[key]
40
+ }
41
+
42
+ return {
43
+ BSON: mongodb.BSON,
44
+ Buffer,
45
+ console: {
46
+ log: (...args: Arguments) => {
47
+ console.log(...args)
48
+ },
49
+ error: (...args: Arguments) => {
50
+ console.error(...args)
51
+ }
46
52
  },
47
- services: {
48
- get: (serviceName: keyof typeof services) => {
49
- try {
50
- return services[serviceName](app, {
53
+ context: {
54
+ request: {
55
+ ...request,
56
+ remoteIPAddress: request?.ip
57
+ },
58
+ user,
59
+ environment: {
60
+ tag: process.env.NODE_ENV
61
+ },
62
+ values: {
63
+ get: (key: string) => process.env[key]
64
+ },
65
+ services: {
66
+ get: getService
67
+ },
68
+ http: getService('api'),
69
+ https: getService('api'),
70
+ functions: {
71
+ execute: (name: keyof typeof functionsList, ...args: Arguments) => {
72
+ const currentFunction = functionsList[name] as Function
73
+ return GenerateContext({
74
+ args,
75
+ app,
51
76
  rules,
52
77
  user,
53
- run_as_system: currentFunction.run_as_system
78
+ currentFunction,
79
+ functionsList,
80
+ services
54
81
  })
55
- } catch (error) {
56
- console.error(
57
- 'Something went wrong while generating context function',
58
- serviceName,
59
- error
60
- )
61
82
  }
62
83
  }
63
- },
64
- functions: {
65
- execute: (name: keyof typeof functionsList, ...args: Arguments) => {
66
- const currentFunction = functionsList[name] as Function
67
- return GenerateContext({
68
- args,
69
- app,
70
- rules,
71
- user,
72
- currentFunction,
73
- functionsList,
74
- services
75
- })
76
- }
77
84
  }
78
85
  }
79
- })
86
+ }