DefinitelyTyped · typescript-bot · Jul 14, 2021 · May 21, 2021 · Jun 17, 2021 · Jun 17, 2021
diff --git a/types/lesgo/exceptions/LesgoException.d.ts b/types/lesgo/exceptions/LesgoException.d.ts
@@ -0,0 +1,13 @@
+export default class LesgoException {
+    name: string;
+
+    message: string;
+
+    statusCode: number;
+
+    code: string;
+
+    extra: any;
+
+    constructor(message: string, errorCode?: string, httpStatusCode?: number, extra?: any);
+}
diff --git a/types/lesgo/exceptions/index.d.ts b/types/lesgo/exceptions/index.d.ts
@@ -0,0 +1,3 @@
+import LesgoException from './LesgoException';
+
+export { LesgoException };
diff --git a/types/lesgo/index.d.ts b/types/lesgo/index.d.ts
@@ -0,0 +1,15 @@
+// Type definitions for lesgo 0.6
+// Project: https://github.com/reflex-media/lesgo-framework#readme
+// Definitions by: xXLXx <https://github.com/xxlxx>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// Minimum TypeScript Version: 3.8
+
+// We did this to adjust to data-api-client
+
+export * from "./middlewares";
+
+export * from "./exceptions";
+
+export * from "./services";
+
+export * from "./utils";
diff --git a/types/lesgo/lesgo-tests.ts b/types/lesgo/lesgo-tests.ts
@@ -0,0 +1,153 @@
+import httpMiddleware from "lesgo/middlewares/httpMiddleware";
+import normalizeHttpRequestMiddleware from "lesgo/middlewares/normalizeHttpRequestMiddleware";
+import successHttpResponseMiddleware from "lesgo/middlewares/successHttpResponseMiddleware";
+import errorHttpResponseMiddleware from "lesgo/middlewares/errorHttpResponseMiddleware";
+import verifyJwtMiddleware from "lesgo/middlewares/verifyJwtMiddleware";
+import normalizeSQSMessageMiddleware from "lesgo/middlewares/normalizeSQSMessageMiddleware";
+
+import LesgoException from "lesgo/exceptions/LesgoException";
+
+import ElasticCacheService from "lesgo/services/ElasticCacheService";
+import "./tests/services/ElasticsearchService";
+import "./tests/services/AuroraDbService";
+import "./tests/services/DynamoDbService";
+import "./tests/services/LoggerService";
+import "./tests/services/S3Service";
+import "./tests/services/SQSService";
+import "./tests/services/FirebaseAdminService";
+import "./tests/services/JWTService";
+
+import { ec, get, set, del } from "lesgo/utils/cache";
+import { encrypt, decrypt, hash, hashMD5 } from "lesgo/utils/crypto";
+import db from "lesgo/utils/db";
+import dynamodb from "lesgo/utils/dynamodb";
+import elasticsearch from "lesgo/utils/elasticsearch";
+import generateUid from "lesgo/utils/generateUid";
+import getJwtSubFromAuthHeader, { getTokenData } from "lesgo/utils/getJwtSubFromAuthHeader";
+import isDecimal from "lesgo/utils/isDecimal";
+import isEmail from "lesgo/utils/isEmail";
+import isEmpty from "lesgo/utils/isEmpty";
+import logger from "lesgo/utils/logger";
+import objectStore, { getObject } from "lesgo/utils/objectStore";
+import prepSQLInsertParams from "lesgo/utils/prepSQLInsertParams";
+import prepSQLUpdateParams from "lesgo/utils/prepSQLUpdateParams";
+import queue, { dispatch } from "lesgo/utils/queue";
+import validateFields from "lesgo/utils/validateFields";
+
+/* Middlewares */
+httpMiddleware({ debugMode: true }); // $ExpectType HttpMiddleware
+normalizeHttpRequestMiddleware(); // $ExpectType NormalizeHttpMiddleware
+successHttpResponseMiddleware(); // $ExpectType SuccessHttpMiddleware
+errorHttpResponseMiddleware({ debugMode: true }); // $ExpectType ErrorHttpMiddleware
+verifyJwtMiddleware(); // $ExpectType VerifyJwtMiddleware
+normalizeSQSMessageMiddleware(); // $ExpectType NormalizeSQSMiddleware
+
+/* Exceptions */
+const lesgoException = new LesgoException("Error");
+lesgoException.name; // $ExpectType string
+lesgoException.message; // $ExpectType string
+lesgoException.statusCode; // $ExpectType number
+lesgoException.code; // $ExpectType string
+lesgoException.extra; // $ExpectType any
+
+/* Services */
+const elasticCache = new ElasticCacheService({
+    url: "12.0.0.1",
+    options: {
+        autoDiscover: true,
+        autoDiscoverInterval: 60000,
+        autoDiscoverOverridesRemove: false,
+        timeout: 30,
+    },
+});
+elasticCache.driver; // $ExpectType Memcached
+
+/* Utils */
+ec("conname"); // $ExpectType Memcached
+(async () => {
+    // $ExpectType boolean
+    await set(
+        "cache-key",
+        {
+            test: 1,
+        },
+        1000,
+    );
+    await get("cache-key"); // $ExpectType any
+    await del("cache-key"); // $ExpectType boolean
+})();
+
+encrypt("this is a test"); // $ExpectType string
+decrypt("TMxLqkHSs8D7tD02ptbtWQxocJO93ZPvqS4IruHEpj8="); // $ExpectType string
+hash("this is a test"); // $ExpectType Buffer
+hashMD5(new Uint8Array([21, 31])); // $ExpectType Buffer
+
+db; // $ExpectType AuroraDbService
+(async () => {
+    await db.select("SELECT * FROM users;", []); // $ExpectType any[]
+})();
+dynamodb; // $ExpectType DynamoDb
+(async () => {
+    await dynamodb.query("analytics", "ForumName = :name", { ":title": { SS: ["The Man"] } }, "#title, tag"); // $ExpectType ItemList
+})();
+elasticsearch("production"); // $ExpectType ElasticsearchService
+(async () => {
+    // $ExpectType string
+    await generateUid({
+        length: 20,
+    });
+})();
+(async () => {
+    // $ExpectType string | null
+    await getJwtSubFromAuthHeader(
+        "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c",
+    );
+})();
+// $ExpectType { sub?: string | undefined; }
+getTokenData(
+    "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c",
+);
+isDecimal(1); // $ExpectType boolean
+isEmail("leo.lavarias@gmail.com"); // $ExpectType boolean
+isEmpty(["test"]); // $ExpectType boolean
+logger; // $ExpectType LoggerService
+// $ExpectType void
+logger.info("SAVED TO DYNAMODB", {
+    id: 10,
+    name: "Leo",
+});
+objectStore; // $ExpectType S3Service
+(async () => {
+    await getObject("TILES/Level4/A3_B3_C2/A5_B67_C59_Tiles.par", "test-aws-imagery"); // $ExpectType GetObjectOutput
+})();
+// $ExpectType SQLInsertParams
+prepSQLInsertParams(
+    {
+        id: 1,
+        name: "Leo",
+    },
+    [{ key: "id" }, { key: "name" }],
+);
+// $ExpectType SQLUpdateParams
+prepSQLUpdateParams(
+    {
+        id: 1,
+        name: "Leo",
+    },
+    [{ key: "id" }, { key: "name" }],
+);
+queue; // $ExpectType SQSService<Record<string, QueueConfig>>
+(async () => {
+    await dispatch("ping", "myqueue"); // $ExpectType SendMessageResult
+})();
+// $ExpectType boolean
+validateFields(
+    {
+        id: 1,
+        name: "test",
+    },
+    [
+        { key: "id", type: "number", required: true },
+        { key: "name", type: "string" },
+    ],
+);
diff --git a/types/lesgo/middlewares/errorHttpResponseMiddleware.d.ts b/types/lesgo/middlewares/errorHttpResponseMiddleware.d.ts
@@ -0,0 +1,15 @@
+import { MiddlewareFunction } from "middy";
+import { HttpGatewayEvent } from "./normalizeHttpRequestMiddleware";
+import { MiddlewareOptions } from "./successHttpResponseMiddleware";
+
+export interface ErrorHttpResponse {
+    headers: Record<string, string | null>;
+    statusCode: number;
+    body: string;
+}
+
+export interface ErrorHttpMiddleware {
+    onError: MiddlewareFunction<HttpGatewayEvent, ErrorHttpResponse>;
+}
+
+export default function errorHttpResponseMiddleware(opts?: MiddlewareOptions): ErrorHttpMiddleware;
diff --git a/types/lesgo/middlewares/httpMiddleware.d.ts b/types/lesgo/middlewares/httpMiddleware.d.ts
@@ -0,0 +1,9 @@
+import { MiddlewareObject } from "middy";
+import { APIGatewayEvent, Context } from "aws-lambda";
+import { NormalizeHttpMiddleware } from "./normalizeHttpRequestMiddleware";
+import { MiddlewareOptions, SuccessHttpMiddleware } from "./successHttpResponseMiddleware";
+import { ErrorHttpMiddleware } from "./errorHttpResponseMiddleware";
+
+export type HttpMiddleware = NormalizeHttpMiddleware & SuccessHttpMiddleware & ErrorHttpMiddleware;
+
+export default function httpMiddleware(opts?: MiddlewareOptions): HttpMiddleware;
diff --git a/types/lesgo/middlewares/index.d.ts b/types/lesgo/middlewares/index.d.ts
@@ -0,0 +1,6 @@
+export * from "./httpMiddleware";
+export * from "./normalizeHttpRequestMiddleware";
+export * from "./errorHttpResponseMiddleware";
+export * from "./successHttpResponseMiddleware";
+export * from "./verifyJwtMiddleware";
+export * from "./normalizeSQSMessageMiddleware";
diff --git a/types/lesgo/middlewares/normalizeHttpRequestMiddleware.d.ts b/types/lesgo/middlewares/normalizeHttpRequestMiddleware.d.ts
@@ -0,0 +1,15 @@
+import { MiddlewareFunction } from "middy";
+import { APIGatewayEvent } from "aws-lambda";
+
+export interface HttpGatewayEvent extends APIGatewayEvent {
+    input: Record<string, any> | null | string;
+    auth: {
+        sub?: Record<string, any> | null;
+    };
+}
+
+export interface NormalizeHttpMiddleware {
+    before: MiddlewareFunction<HttpGatewayEvent, {}>;
+}
+
+export default function normalizeHttpRequestMiddleware(): NormalizeHttpMiddleware;
diff --git a/types/lesgo/middlewares/normalizeSQSMessageMiddleware.d.ts b/types/lesgo/middlewares/normalizeSQSMessageMiddleware.d.ts
@@ -0,0 +1,12 @@
+import { MiddlewareFunction } from "middy";
+import { SQSEvent, SQSRecord } from "aws-lambda";
+
+export interface SQSEventWithCollection extends SQSEvent {
+    collection?: Pick<SQSRecord, "messageId" | "receiptHandle"> & Record<string, any>;
+}
+
+export interface NormalizeSQSMiddleware {
+    before: MiddlewareFunction<SQSEventWithCollection, {}>;
+}
+
+export default function normalizeSQSMessageMiddleware(): NormalizeSQSMiddleware;
diff --git a/types/lesgo/middlewares/successHttpResponseMiddleware.d.ts b/types/lesgo/middlewares/successHttpResponseMiddleware.d.ts
@@ -0,0 +1,21 @@
+import { MiddlewareFunction } from "middy";
+import { HttpGatewayEvent } from "./normalizeHttpRequestMiddleware";
+
+export interface MiddlewareOptions {
+    headers?: Record<string, string>;
+    debugMode?: boolean;
+    zipWhenRequest?: Array<"ELB" | "APIGATEWAY">;
+}
+
+export interface SuccessHttpResponse {
+    headers: Record<string, string | null>;
+    statusCode: number;
+    body: string;
+    isBase64Encoded: boolean;
+}
+
+export interface SuccessHttpMiddleware {
+    after: MiddlewareFunction<HttpGatewayEvent, SuccessHttpResponse>;
+}
+
+export default function successHttpResponseMiddleware(opts?: MiddlewareOptions): SuccessHttpMiddleware;
diff --git a/types/lesgo/middlewares/verifyJwtMiddleware.d.ts b/types/lesgo/middlewares/verifyJwtMiddleware.d.ts
@@ -0,0 +1,12 @@
+import { MiddlewareFunction } from "middy";
+import { APIGatewayEvent } from "aws-lambda";
+
+export interface JwtGatewayEvent extends APIGatewayEvent {
+    decodedJwt?: string;
+}
+
+export interface VerifyJwtMiddleware {
+    before: MiddlewareFunction<JwtGatewayEvent, {}>;
+}
+
+export default function verifyJwtMiddleware(): VerifyJwtMiddleware;
diff --git a/types/lesgo/package.json b/types/lesgo/package.json
@@ -0,0 +1,9 @@
+{
+    "private": true,
+    "dependencies": {
+        "middy": "^0.29.0",
+        "@elastic/elasticsearch": "^7.4.0",
+        "aws-sdk": "^2.541.0",
+        "firebase-admin": "^9.3.0"
+    }
+}
diff --git a/types/lesgo/services/AuroraDbService.d.ts b/types/lesgo/services/AuroraDbService.d.ts
@@ -0,0 +1,34 @@
+import DataApiClient = require("data-api-client");
+import { PaginatorObject } from "./pagination/Paginator";
+
+export type iParams = Parameters<typeof DataApiClient>[0];
+
+export type iDataAPIClient = ReturnType<typeof DataApiClient>;
+
+export type AuroraDbServiceParams = Pick<iParams, "secretArn" | "resourceArn" | "database">;
+
+export default class AuroraDbService {
+    protected client: iDataAPIClient;
+
+    constructor(params?: AuroraDbServiceParams);
+
+    connect(opts: AuroraDbServiceParams): void;
+
+    query(sql: string, params: [] | unknown): ReturnType<iDataAPIClient["query"]>;
+
+    select(sql: string, params: [] | unknown): Promise<any[]>;
+
+    selectFirst(sql: string, params: [] | unknown): Promise<any>;
+
+    selectPaginate(
+        sql: string,
+        params: [] | unknown,
+        perPage?: number,
+        currentPage?: number,
+        total?: number | null,
+    ): PaginatorObject<any>;
+
+    insert(sql: string, sqlParams: [] | unknown): Promise<any>;
+
+    update(sql: string, sqlParams: [] | unknown): Promise<void>;
+}
Original file line number	Diff line number	Diff line change
		@@ -0,0 +1,3 @@
		import LesgoException from './LesgoException';

		export { LesgoException };