Forem: Christian Prado Ciokler

Get started with this Top 5 Cloud Providers free tiers.

Christian Prado Ciokler — Fri, 02 Jun 2023 04:55:30 +0000

In recent years, cloud computing has become one of the most popular ways to host and manage software applications. Cloud providers offer a vast range of services for individuals and businesses to choose from - ranging from virtual machines to databases to object storage. Choosing the appropriate cloud provider and services can be a challenging job for many developers, as different providers offer different combinations of services, pricing, and reliability. In this post, we will take a look at the top five cloud providers based on the free tiers they offer - Amazon Web Services (AWS), Google Cloud Platform (GCP), Microsoft Azure, Oracle Cloud, and IBM Cloud.

1. Google Cloud Platform

Google Cloud Platform offers a generous free tier that includes many of the core features required to develop and host a simple web application. The free tier includes:

App Engine: 28 frontend instance hours and 9 backend instance hours per day.
Cloud Firestore: 1 GB storage, 50,000 reads, 20,000 writes, and 20,000 deletes per day.
Compute Engine: 1 non-preemptible e2-micro, 30 GB HDD, and 5 GB snapshot storage (restricted to certain regions), 1 GB network egress from North America to all region destinations (excluding China and Australia) per month.
Cloud Storage: 5 GB, 1 GB network egress.
Cloud Shell: A web-based Linux shell/basic IDE with 5 GB of persistent storage. 60 hours limit per week.
Cloud Pub/Sub: 10 GB of messages per month.
Cloud Functions: 2 million invocations per month (includes both background and HTTP invocations).
Cloud Run: 2 million requests per month, 360,000 GB-seconds of memory, 180,000 vCPU-seconds of compute time, 1 GB network egress from North America per month.
Google Kubernetes Engine: No cluster management fee for one zonal cluster. Each user node is charged at standard Compute Engine pricing.
BigQuery: 1 TB of querying per month, 10 GB of storage each month.
Cloud Build: 120 build-minutes per day.
Cloud Source Repositories: Up to 5 Users, 50 GB Storage, 50 GB Egress.
Google Colab: Free Jupyter Notebooks development environment.

While the Google Cloud Platform free tier is quite comprehensive, it is important to note that many of the services have certain limitations and usage caps that may not be sufficient. Additionally, there are some services that are not included in the free tier, such as Google Kubernetes Engine cluster management fees and Cloud SQL storage fees.

2. Amazon Web Services

Amazon Web Services is widely regarded as one of the most mature and reliable cloud providers due to its long-standing presence in the market, and the breadth and depth of its service offerings. AWS offers a free tier that includes a range of services suitable for small web applications, including:

CloudFront: 1 TB egress per month.
Cloudwatch: 10 custom metrics and 10 alarms.
CodeBuild: 100 min of build time per month.
CodeCommit: 5 active users, 50 GB storage, and 10,000 request per month.
CodePipeline: 1 active pipeline per month.
DynamoDB: 25 GB NoSQL DB.
EC2: 750 hours per month of t2.micro or t3.micro(12mo). 100 GB egress per month.
EBS: 30 GB per month of General Purpose (SSD) or Magnetic(12mo).
Elastic Load Balancing: 750 hours per month(12mo).
RDS: 750 hours per month of db.t2.micro, db.t3.micro, or db.t4g.micro, 20 GB of General Purpose (SSD) storage, 20 GB of storage backups.
Glacier: 10 GB long-term object storage.
Lambda: 1 million requests per month.
SNS: 1 million publishes per month.
SES: 62,000 messages per month.
SQS: 1 million messaging queue requests.

One of the significant advantages of AWS is the extensive set of machine learning and artificial intelligence services that are available beyond the free tier. However, the AWS free tier has a limited selection of services, and users may quickly outgrow the free tier services offered.

3. Microsoft Azure

Microsoft Azure offers a wide array of services for individuals and businesses to develop and host software applications. The Azure free tier is suitable for smaller-scale web applications and offers:

Virtual Machines: 1 B1S Linux VM, 1 B1S Windows VM (12mo).
App Service: 10 web, mobile, or API apps (60 CPU minutes / day).
Functions: 1 million requests per month.
DevTest Labs: Enable fast, easy, and lean dev-test environments.
Active Directory: 500,000 objects.
Active Directory B2C: 50,000 monthly stored users.
Azure DevOps: 5 active users, unlimited private Git repos.
Azure Pipelines: 10 free parallel jobs with unlimited minutes for open source for Linux, macOS, and Windows.
Microsoft IoT Hub: 8,000 messages per day.
Load Balancer: 1 free public load balanced IP (VIP).
Notification Hubs: 1 million push notifications.
Bandwidth: 15 GB Inbound(12mo) & 5 GB egress per month.
Cosmos DB: 5 GB storage and 400 RUs of provisioned throughput.
Static Web Apps: Build, deploy and host static apps and serverless functions, with free SSL, Authentication/Authorization and custom domains.
Storage: 5 GB LRS File or Blob storage (12mo).
Cognitive Services: AI/ML APIs (Computer Vision, Translator, Face detection, Bots...) with free tier including limited transactions.
Cognitive Search: AI-based search and indexation service, free for 10,000 documents.
Azure Kubernetes Service: Managed Kubernetes service, free cluster management.
Event Grid: 100K ops/month.

The Azure free tier includes many services to support web application development, making it an effective choice for smaller-scale web application development.

4. Oracle Cloud

Oracle Cloud offers a relatively new cloud platform that is quickly gaining popularity due to the breadth and speed of its offerings. Oracle Cloud provides a free tier that includes:

Compute: 2 AMD-based Compute VMs with 1/8 OCPU and 1 GB memory each, 4 Arm-based Ampere A1 cores, and 24 GB of memory usable as one VM or up to 4 VMs. Instances will be reclaimed when deemed idle.
Block Volume: 2 volumes, 200 GB total (used for compute).
Object Storage: 10 GB.
Load balancer: 1 instance with 10 Mbps.
Databases: 2 DBs, 20 GB each.
Monitoring: 500 million ingestion data points, 1 billion retrieval data points.
Bandwidth: 10 TB egress per month, speed limited to 50 Mbps on x64 based VM, 500 Mbps * core count on ARM-based VM.
Public IP: 2 IPv4 for VMs, 1 IPv4 for load balancer.
Notifications: 1 million delivery options per month, 1000 emails sent per month.

However, it should be taken into consideration that Oracle Cloud is still mostly new in the market and has a relatively limited set of services compared to competitors. Nevertheless, its fast-growing catalog of services is worth watching.

5. IBM Cloud

IBM Cloud is another popular cloud provider with a range of offerings for businesses and individuals. IBM Cloud offers a free tier that includes:

Cloud Functions: 5 million executions per month.
Object Storage: 25 GB per month.
Cloudant Database: 1 GB of data storage.
Db2 Database: 100 MB of data storage.
API Connect: 50,000 API calls per month.
Availability Monitoring: 3 million data points per month.
Log Analysis: 500 MB of daily log.

IBM Cloud's free offerings work well for developing and hosting small applications, but the free storage and database services are not as generous as competitors such as Google Cloud Platform.

Choosing a cloud provider can be a daunting task, especially for businesses that are seeking reliable and cost-effective services. Among the top five cloud providers mentioned in this article, each cloud provider has a unique set of advantages, limitations, and services, and developers need to consider them while making a decision. The free tiers of AWS, GCP, Azure, Oracle Cloud, and IBM Cloud provide a good starting point for you to experiment with services and develop smaller applications, but they may not be suitable for larger-scale or complex applications. You should perform your own research to determine the best match for the needs of your project.

How to Generate a Quick Node.js Project with TypeScript.

Christian Prado Ciokler — Sun, 02 Apr 2023 19:31:22 +0000

Photo by Blake Connally on Unsplash

If you're a developer, you know that starting a new project can be a daunting task. Setting up your development environment, installing the necessary packages, configuring the build tools, and more can take a lot of time and effort. Fortunately, TypeScript makes it easy to create a new Node project without all the hassle. In this post, we'll walk you through the steps to generate a quick Node project with TypeScript.

Here are the steps you need to follow:

Step 1: Install Node.js and npm if you haven't done it yet.

Step 2: Open a terminal window and navigate to the folder where you want to create your project.

Step 3: Run the following command to create a new folder for your project:

    mkdir my-project && cd my-project

Step 4: Initialize npm for your project using the following command:

    npm init -y

Step 5: Install the necessary dependencies for a TypeScript project:

    npm install --save-dev typescript ts-node @types/node

Step 6: Create a TypeScript configuration file named tsconfig.json in your project's root directory with the following content:

{
  "compilerOptions": {
    "target": "es6",
    "module": "commonjs",
    "outDir": "dist",
    "strict": true,
    "esModuleInterop": true
  },
  "include": ["src/**/*.ts"],
  "exclude": ["node_modules"]
}

Step 7: Create a folder named src in the root directory of your project, and create a TypeScript file named index.ts inside it:

    mkdir src && touch src/index.ts // linux
    mkdir src ;; New-Item -Type File src/index.ts // windows

Step 8: Open the index.ts file in your favorite code editor and write some TypeScript code, for example:

const message: string = 'Hello, TypeScript!';
console.log(message);

Step 9: In your package.json file, add a new script to compile and run your TypeScript code:

{
  "scripts": {
    "start": "ts-node src/index.ts",
    "build": "tsc"
  }
}

Step 10: Finally, run the following command to compile and run your TypeScript code:

npm run start

This will compile your TypeScript code into JavaScript and run it using ts-node. You can also run the build script to compile your code and generate JavaScript files in the dist folder:

npm run build

Thanks and have a great day ahead!

Don't forget to give this post a heart if you found it useful. It helps others discover helpful posts like this one.

150+ Typescript one-liners [code snippets].

Christian Prado Ciokler — Sun, 24 Jul 2022 04:51:00 +0000

OneLiners

OneLiners are short snippets of code that are used in many places in the codebase. This is a collection of 150+ one-liners written in typescript.

Table of content

Array one liners
Date one liners
Functions one liners
Math one liners
Misc one liners
Objects one liners
String one liners

🙏 Hope you like 👍 this post, let's get down to business. 🚀

Array one liners ☝️

1. Cast a value as an array

export const castArray = <T, _>(value: T | T[]): T[] => (Array.isArray(value) ? value : [value]);
// castArray(1); // [1]
// castArray([1, 2, 3]); // [1, 2, 3]

2. Check if an array is empty

export const isEmpty = <T, _>(arr: T[]): boolean => Array.isArray(arr) && !arr.length;
// isEmpty([]); // true
// isEmpty([1, 2, 3]); // false

3. Clone an array

export const clone = <T, _>(arr: T[]): T[] => [...arr];
// clone([1,2,3]); // [1,2,3]

4. Compare two arrays

export const isEqual = <T, _>(a: T[], b: T[]): boolean => JSON.stringify(a) === JSON.stringify(b);
// isEqual([1, 2, 3], [1, 2, 3]); // true
// isEqual([1, 2, 3], [1, '2', 3]); // false

5. Compare two arrays regardless of order

export const isEqualWithoutOrder = <T, _>(a: T[], b: T[]): boolean =>
JSON.stringify([...new Set(a)].sort()) === JSON.stringify([...new Set(b)].sort());
// isEqualWithoutOrder([1, 2, 3], [1, 2, 3]); // true
// isEqualWithoutOrder([1, 2, 3], [1, 3, 2]); // true
// isEqualWithoutOrder([1, 2, 3], [1, '2', 3]); // false

6. Convert an array of objects to a single object

export const toObject = <T extends Record<string, any>, K extends keyof T>(arr: T[], key: K): Record<string, T> =>
arr.reduce((a, b) => ({ ...a, [b[key]]: b }), {});
// toObject(
// [
// { id: '1', name: 'Alpha', gender: 'Male' },
// { id: '2', name: 'Bravo', gender: 'Male' },
// { id: '3', name: 'Charlie', gender: 'Female' },
// ],
// 'id'
// );
{
'1': { id: '1', name: 'Alpha', gender: 'Male' },
'2': { id: '2', name: 'Bravo', gender: 'Male' },
'3': { id: '3', name: 'Charlie', gender: 'Female' },
}

7. Convert an array of strings to numbers

export const toNumbers = (arr: string[]): number[] => arr.map(Number);
// toNumbers(['2', '3', '4']); // [2, 3, 4]

8. Count by the properties of an array of objects

export const countBy = <T extends Record<string, string>, K extends keyof T>(
  arr: T[],
  prop: K
): Record<string, number> =>
  arr.reduce((prev, curr) => ((prev[curr[prop]] = ++prev[curr[prop]] || 1), prev), {} as Record<string, number>);
// countBy(
// [
// { branch: 'audi', model: 'q8', year: '2019' },
// { branch: 'audi', model: 'rs7', year: '2020' },
// { branch: 'ford', model: 'mustang', year: '2019' },
// { branch: 'ford', model: 'explorer', year: '2020' },
// { branch: 'bmw', model: 'x7', year: '2020' }
// ],
// 'branch'
// );
// { 'audi': 2, 'ford': 2, 'bmw': 1 }

9. Count the occurrences of a value in an array

export const countOccurrences = <T, _>(arr: T[], val: T): number => arr.reduce((a, v) => (v === val ? a + 1 : a), 0);
// countOccurrences([2, 1, 3, 3, 2, 3], 2); // 2

10. Count the occurrences of array elements

export const countOccurrencesElements = <T extends string | number>(arr: T[]): Record<T, number> =>
  arr.reduce((prev, curr) => ((prev[curr] = ++prev[curr] || 1), prev), {} as Record<T, number>);
// countOccurrencesElements([2, 1, 3, 3, 2, 3]); // { '1': 1, '2': 2, '3': 3 }

11. Create an array of cumulative sum

export const accumulate = (arr: number[]): number[] =>
  arr.reduce((a, b, i) => (i === 0 ? [b] : [...a, b + a[i - 1]]), [0]);
// accumulate([1, 2, 3, 4]); // [1, 3, 6, 10]

12. Create an array of numbers in the given range

export const range = (min: number, max: number): number[] => [...Array(max - min + 1).keys()].map((i) => i + min);
// range(5, 10); // [5, 6, 7, 8, 9, 10]

13. Find the closest number from an array

export const closest = (arr: number[], n: number): number => arr.sort((a, b) => Math.abs(a - n) - Math.abs(b - n))[0];
// closest([29, 87, 8, 78, 97, 20, 75, 33, 24, 17], 50); // 33

14. Find the index of the last matching item of an array

export const lastIndex = <T, _>(arr: T[], predicate: (a: T) => boolean): number =>
arr.map((item) => predicate(item)).lastIndexOf(true);
// lastIndex([1, 3, 5, 7, 9, 2, 4, 6, 8], (i) => i % 2 === 1); // 4
// lastIndex([1, 3, 5, 7, 9, 8, 6, 4, 2], (i) => i > 6); // 5

15. Find the index of the maximum item of an array

export const indexOfMax = (arr: number[]): number => arr.reduce((prev, curr, i, a) => (curr > a[prev] ? i : prev), 0);
// indexOfMax([1, 3, 9, 7, 5]); // 2
// indexOfMax([1, 3, 7, 7, 5]); //

16. Find the index of the minimum item of an array

export const indexOfMin = (arr: number[]): number => arr.reduce((prev, curr, i, a) => (curr < a[prev] ? i : prev), 0);
// indexOfMin([6, 4, 8, 2, 10]); // 3
// indexOfMin([6, 4, 2, 2, 10]); // 2

17. Find the length of the longest string in an array

export const findLongest = (words: string[]): number => Math.max(...words.map((el) => el.length));
// findLongest(['always', 'look', 'on', 'the', 'bright', 'side', 'of', 'life']); // 6

18. Find the maximum item of an array by given key

export const maxBy = <T extends Record<string, any>, K extends keyof T>(arr: T[], key: K): T =>
  arr.reduce((a, b) => (a[key] >= b[key] ? a : b), {} as T);
// const people = [
// { name: 'Bar', age: 24 },
// { name: 'Baz', age: 32 },
// { name: 'Foo', age: 42 },
// { name: 'Fuzz', age: 36 }
// ];
// maxBy(people, 'age'); // { name: 'Foo', age: 42 }

19. Find the maximum item of an array

export const max = (arr: number[]): number => Math.max(...arr);
// max([1, 3, 9, 7, 5]); // 9

20. Find the minimum item of an array by given key

export const minBy = <T extends Record<string, any>, K extends keyof T>(arr: T[], key: K): T =>
  arr.reduce((a, b) => (a[key] < b[key] ? a : b), {} as T);
// const people = [
// { name: 'Bar', age: 24 },
// { name: 'Baz', age: 32 },
// { name: 'Foo', age: 42 },
// { name: 'Fuzz', age: 36 },
// ];
// minBy(people, 'age'); // { name: 'Bar', age: 24 }

21. Find the minimum item of an array

export const min = (arr: number[]): number => Math.min(...arr);
// min([1, 3, 9, 7, 5]); // 1

22. Get all arrays of consecutive elements

export const getConsecutiveArrays = <T, _>(arr: T[], size: number): T[][] =>
  size > arr.length ? [] : arr.slice(size - 1).map((_, i) => arr.slice(i, size + i));
// getConsecutiveArrays([1, 2, 3, 4, 5], 2); // [[1, 2], [2, 3], [3, 4], [4, 5]]
// getConsecutiveArrays([1, 2, 3, 4, 5], 3); // [[1, 2, 3], [2, 3, 4], [3, 4, 5]]
// getConsecutiveArrays([1, 2, 3, 4, 5], 6); // []

23. Get all n-th items of an array

export const getNthItems = <T, _>(arr: T[], nth: number): T[] => arr.filter((_, i) => i % nth === nth - 1);
// getNthItems([1, 2, 3, 4, 5, 6, 7, 8, 9], 2); // [2, 4, 6, 8]
// getNthItems([1, 2, 3, 4, 5, 6, 7, 8, 9], 3); // [3, 6, 9]

24. Get indices of a value in an array

export const indices = <T>(arr: T[], value: T): number[] =>
  arr.reduce((acc, v, i) => (v === value ? [...acc, i] : acc), [] as number[]);
// indices(['h', 'e', 'l', 'l', 'o'], 'l'); // [2, 3]
// indices(['h', 'e', 'l', 'l', 'o'], 'w'); // []

25. Get the average of an array

export const average = (arr: number[]): number => arr.reduce((a, b) => a + b, 0) / arr.length;
// average([1, 2, 3, 4, 5]); // 3

26. Get the intersection of arrays

export const getIntersection = <T, _>(a: T[], ...arr: T[][]): T[] =>
[...new Set(a)].filter((v) => arr.every((b) => b.includes(v)));
// getIntersection([1, 2, 3], [2, 3, 4, 5]); // [2, 3]
// getIntersection([1, 2, 3], [2, 3, 4, 5], [1, 3, 5]); // [3]

27. Get the rank of an array of numbers

export const ranking = (arr: number[]): number[] => arr.map((x, y, z) => z.filter((w) => w > x).length + 1);
// ranking([80, 65, 90, 50]); // [2, 3, 1, 4]
// ranking([80, 80, 70, 50]); // [1, 1, 3, 4]
// ranking([80, 80, 80, 50]); // [1, 1, 1, 4]

28. Get the sum of an array of numbers

export const sum = (arr: number[]): number => arr.reduce((a, b) => a + b, 0);
// sun([1, 2, 3, 4, 5]); // 15

29. Get the unique values of an array

export const unique = <T>(arr: T[]): T[] => [...new Set(arr)];
// unique([1, 2, 3, 1, 4, 4, 5]); // [1, 2, 3, 4, 5]

30. Get union of arrays

export const union = <T, _>(...arr: T[][]): T[] => [...new Set(arr.flat())];
// union([1, 2], [2, 3], [3]); // [1, 2, 3]

31. Group an array of objects by a key

export const groupBy = <T extends Record<string, any>, K extends keyof T>(arr: T[], key: K): Record<string, T[]> =>
  arr.reduce((acc, item) => ((acc[item[key]] = [...(acc[item[key]] || []), item]), acc), {} as Record<string, T[]>);
// groupBy(
// [
// { branch: 'audi', model: 'q8', year: '2019' },
// { branch: 'audi', model: 'rs7', year: '2020' },
// { branch: 'ford', model: 'mustang', year: '2019' },
// { branch: 'ford', model: 'explorer', year: '2020' },
// { branch: 'bmw', model: 'x7', year: '2020' }
// ],
// 'branch'
// );
{
// audi: [
// { branch: 'audi', model: 'q8', year: '2019' },
// { branch: 'audi', model: 'rs7', year: '2020' }
// ],
// bmw: [
// { branch: 'bmw', model: 'x7', year: '2020' }
// ],
// ford: [
// { branch: 'ford', model: 'mustang', year: '2019' },
// { branch: 'ford', model: 'explorer', year: '2020' }
// ],
// }

32. Intersperse element between elements

export const intersperse = <T>(a: T[], s: T): T[] => [...Array(2 * a.length - 1)].map((_, i) => (i % 2 ? s : a[i / 2]));
// intersperse(['A', 'B', 'C'], '/'); // ['A', '/', 'B', '/', 'C']
// intersperse([<li>A</li>, <li>B</li>, <li>C</li>], <li>/</li>); // [<li>A</li>, <li>/</li>, <li>B</li>, <li>/</li>, <li>C</li>]

33. Merge two arrays

export const merge = <T, _>(a: T[], b: T[]): T[] => [...a, ...b];
// merge([1, 2, 3], [4, 5, 6]); // [1, 2, 3, 4, 5, 6]

34. Partition an array based on a condition

// export const partition = <T, _>(arr: T[], criteria: (a: T) => boolean): T[][] =>
// arr.reduce((acc, i) => (acc[criteria(i) ? 0 : 1].push(i), acc), [[], []]);
// partition([1, 2, 3, 4, 5], (n) => n % 2); // [[1, 3, 5], [2, 4]]

35. Remove duplicate values in an array

export const removeDuplicate = <T, _>(arr: T[]): T[] => arr.filter((i) => arr.indexOf(i) === arr.lastIndexOf(i));
// removeDuplicate(['h', 'e', 'l', 'l', 'o', 'w', 'o', 'r', 'l', 'd']); // ['h', 'e', 'w', 'r', 'd']

36. Remove falsy values from array

export const removeFalsy = <T, _>(arr: T[]): T[] => arr.filter(Boolean);
// ['a string', true, 5, 'another string']

37. Repeat an array

export const repeat = <T, _>(arr: T[], n: number): T[] => Array(n).fill(arr).flat();
repeat([1, 2, 3], 3); // [1, 2, 3, 1, 2, 3, 1, 2, 3]

38. Shuffle an array

export const shuffle = <T, _>(arr: T[]): T[] =>
arr
.map((a) => ({ sort: Math.random(), value: a }))
.sort((a, b) => a.sort - b.sort)
.map((a) => a.value);
// shuffle([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]); // [9, 1, 10, 6, 8, 5, 2, 3, 7, 4]

39. Sort an array of items by given key

export const sortBy = <T extends Record<string, any>, K extends keyof T>(arr: T[], k: K): T[] =>
  arr.concat().sort((a, b) => (a[k] > b[k] ? 1 : a[k] < b[k] ? -1 : 0));
// const people = [
// { name: 'Foo', age: 42 },
// { name: 'Bar', age: 24 },
// { name: 'Fuzz', age: 36 },
// { name: 'Baz', age: 32 }
// ];
// sortBy(people, 'age');

// [
// { name: 'Bar', age: 24 },
// { name: 'Baz', age: 32 },
// { name: 'Fuzz', age: 36 },
// { name: 'Foo', age: 42 },
// ]

40. Sort an array of numbers

export const sort = (arr: number[]): number[] => arr.sort((a, b) => a - b);
// sort([1, 5, 2, 4, 3]); // [1, 2, 3, 4, 5]

41. Split an array into chunks

export const chunk = <T>(arr: T[], size: number): T[][] =>
  arr.reduce((acc, e, i) => (i % size ? acc[acc.length - 1].push(e) : acc.push([e]), acc), [] as T[][]);
// chunk([1, 2, 3, 4, 5, 6, 7, 8], 3); // [[1, 2, 3], [4, 5, 6], [7, 8]]
// chunk([1, 2, 3, 4, 5, 6, 7, 8], 4); // [[1, 2, 3, 4], [5, 6, 7, 8]]

42. Swap the rows and columns of a matrix

export const transpose = <T>(matrix: T[][]): T[][] => matrix[0].map((col, i) => matrix.map((row) => row[i]));
// transpose([
// // [
// [1, 2, 3], // [1, 4, 7],
// [4, 5, 6], // [2, 5, 8],
// [7, 8, 9] // [3, 6, 9],
// ]); // ]

43. Swap two array items

export const swapItems = <T, _>(a: T[], i: number, j: number): T[] =>
(a[i] && a[j] && [...a.slice(0, i), a[j], ...a.slice(i + 1, j), a[i], ...a.slice(j + 1)]) || a;
// swapItems([1, 2, 3, 4, 5], 1, 4); // [1, 5, 3, 4, 2]

44. Get all subsets of an array

export const getSubsets = <T>(arr: T[]): T[][] =>
  arr.reduce((prev, curr) => prev.concat(prev.map((k) => k.concat(curr))), [[]] as T[][]);
// getSubsets([1, 2]); // [[], [1], [2], [1, 2]]
// getSubsets([1, 2, 3]); // [[], [1], [2], [1, 2], [3], [1, 3], [2, 3], [1, 2, 3]]

Date one liners ☝️

1. Add AM PM suffix to an hour

export const suffixAmPm = (h: number): string => `${h % 12 === 0 ? 12 : h % 12}${h < 12 ? 'am' : 'pm'}`;
// suffixAmPm(0); // '12am'
// suffixAmPm(5); // '5am'
// suffixAmPm(12); // '12pm'
// suffixAmPm(15); // '3pm'
// suffixAmPm(23); // '11pm'

2. Calculate the number of difference days between two dates

export const diffDays = (date: Date, otherDate: Date): number =>
Math.ceil(Math.abs(date.valueOf() - otherDate.valueOf()) / (1000 * 60 * 60 * 24));
// diffDays(new Date('2014-12-19'), new Date('2020-01-01')); // 1839

3. Calculate the number of months between two dates

export const monthDiff = (startDate: Date, endDate: Date): number =>
Math.max(0, (endDate.getFullYear() - startDate.getFullYear()) * 12 - startDate.getMonth() + endDate.getMonth());
// monthDiff(new Date('2020-01-01'), new Date('2021-01-01')); // 12

4. Compare two dates

export const compare = (a: Date, b: Date): boolean => a.getTime() > b.getTime();
// compare(new Date('2020-03-30'), new Date('2020-01-01')); // true

5. Convert a date to YYYY-MM-DD format

export const formatYmd = (date: Date): string => date.toISOString().slice(0, 10);
// formatYmd(new Date()); // 2020-05-06

6. Convert a date to YYYY-MM-DD HH:MM:SS format

export const formatYmdHis = (date: Date): string => date.toISOString().slice(0, 19);
// formatYmdHis(new Date()); // 2020-05-06T15:00:00.000Z

7. Convert seconds to hh:mm:ss format

export const formatSeconds = (s: number): string => new Date(s * 1000).toISOString().substr(11, 8);
// formatSeconds(200); // 00:03:20
// formatSeconds(500); // 00:08:20

8. Extract year, month, day, hour, minute, second and millisecond from a date

export const extract = (date: Date): string[] =>
  date
    .toISOString()
    .split(/[^0-9]/)
    .slice(0, -1);
// extract(new Date()); // ['2020', '05', '06', '15', '00', '00', '00']

9. Format a date for the given locale

export const format = (date: Date, locale: string): string => new Intl.DateTimeFormat(locale).format(date);
// format(new Date(), 'pt-BR'); // 06/05/2020

10. Get the current quarter of a date

export const getQuarter = (d = new Date()): number => Math.ceil((d.getMonth() + 1) / 3);
// getQuarter(new Date('2020-01-01')); // 1

11. Get the current timestamp in seconds

export const tseconds = (): number => Math.floor(new Date().getTime() / 1000);
// ts(); // 1588888888

12. Get the day of the year from a date

export const dayOfYear = (date: Date): number =>
Math.floor((date.valueOf() - new Date(date.getFullYear(), 0, 0).valueOf()) / (1000 * 60 * 60 * 24));
// dayOfYear(new Date(2020, 04, 16)); // 137

13. Get the first date in the month of a date

export const getFirstDate = (d = new Date()): Date => new Date(d.getFullYear(), d.getMonth(), 1);
// getFirstDate(new Date('2020-01-01')); // 2020-01-01

14. Get the last date in the month of a date

export const getLastDate = (d = new Date()): Date => new Date(d.getFullYear(), d.getMonth() + 1, 0);
// getLastDate(new Date('2020-02-01')); // 2020-02-29

15. Get the month name of a date

export const getMonthName = (date: Date): string =>
  [
    'January',
    'February',
    'March',
    'April',
    'May',
    'June',
    'July',
    'August',
    'September',
    'October',
    'November',
    'December'
  ][date.getmonth()];
// getMonthName(new Date('2020-01-01')); // January

16.Get the number of days in given month

export const daysInMonth = (month: number, year: number): number => new Date(year, month, 0).getDate();
// daysInMonth(2, 2020); // 29

17. Get the timezone string

export const getTimezone = (): string => Intl.DateTimeFormat().resolvedOptions().timeZone;
// getTimezone(); // 'Asia/Saigon'

18. Get the tomorrow date

export const tomorrow: Date = ((d) => new Date(d.setDate(d.getDate() + 1)))(new Date());
// tomorrow; // 2020-05-07

19. Get the total number of days in a year

export const numberOfDays = (year: number): number => (new Date(year, 1, 29).getDate() === 29 ? 366 : 365);
// numberOfDays(2020); // 366

20. Get the weekday of a date

export const getWeekday = (date: Date): string =>
  ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'][date.getday()];
// getWeekday(new Date('2020-01-01')); // Sunday

21. Get the yesterday date

export const yesterday: Date = ((d) => new Date(d.setDate(d.getDate() - 1)))(new Date());
// yesterday; // 2020-05-06

22. Initialize the current date but set time to midnight

export const midnightOfToday = (): Date => new Date(new Date().setHours(0, 0, 0, 0));
// midnightOfToday(); // 2020-05-06T00:00:00.000Z

23. Sort an array of dates

export const sortDescending = (arr: Date[]): Date[] => arr.sort((a, b) => a.getTime() - b.getTime());
// sortDescending([new Date('2020-01-01'), new Date('2020-01-02')]); // [new Date('2020-01-02'), new Date('2020-01-01')]
export const sortAscending = (arr: Date[]): Date[] => arr.sort((a, b) => b.getTime() - a.getTime());
// sortAscending([new Date('2020-01-01'), new Date('2020-01-02')]); // [new Date('2020-01-01'), new Date('2020-01-02')]

Functions one liners ☝️

1. Box handler

export const boxHandler = (x: any): { next: (f: any) => any; done: (f: any) => any } => ({
  next: (f: any) => boxHandler(f(x)),
  done: (f: any) => f(x)
});
// const getMoney = (price) => Number.parseFloat(price.replace(/\$/, ''));
// const getPercent = (percent) => Number.parseFloat(percent.replace(/\%/)) * 0.01;

// const getDiscountPrice = (price, discount) =>
// boxHandler(getMoney(price))
// .done((cents) => boxHandler(getPercent(discount)).next((save) => cents - cents * save))
// .done((res) => res);

// getDiscountPrice('$6.00', '20%'); // 4.8

2. Check if a value is a function

export const isFunction = (v: any): boolean =>
  ['[object Function]', '[object GeneratorFunction]', '[object AsyncFunction]', '[object Promise]'].includes(
    Object.prototype.toString.call(v)
  );
// isFunction(function () {}); // true
// isFunction(function* () {}); // true
// isFunction(async function () {}); // true

3. Check if a value is a generator function

export const isGeneratorFunction = (v: any): boolean =>
  Object.prototype.toString.call(v) === '[object GeneratorFunction]';
// isGeneratorFunction(function () {}); // false
// isGeneratorFunction(function* () {}); // true

4. Check if a value is an async function

export const isAsyncFunction = (v: any): boolean => Object.prototype.toString.call(v) === '[object AsyncFunction]';
// isAsyncFunction(function () {}); // false
// isAsyncFunction(function* () {}); // false
// isAsyncFunction(async function () {}); // true

5. Compose functions from left to right

export const pipe =
  (...fns: any[]) =>
  (x: any) =>
    fns.reduce((y, f) => f(y), x);
// const lowercase = (str) => str.toLowerCase();
// const capitalize = (str) => `${str.charAt(0).toUpperCase()}${str.slice(1)}`;
// const reverse = (str) => str.split('').reverse().join('');

// const fn = pipe(lowercase, capitalize, reverse);

// We will execute `lowercase`, `capitalize` and `reverse` in order
// fn('Hello World') === 'dlrow olleH';

6. Compose functions from right to left

export const compose =
  (...fns: any[]) =>
  (x: any) =>
    fns.reduceRight((y, f) => f(y), x);
// const lowercase = (str) => str.toLowerCase();
// const capitalize = (str) => `${str.charAt(0).toUpperCase()}${str.slice(1)}`;
// const reverse = (str) => str.split('').reverse().join('');

// const fn = compose(reverse, capitalize, lowercase);

// // We will execute `lowercase`, `capitalize` and `reverse` in order
// fn('Hello World') === 'dlrow olleH';

7. Curry a function

export const curry = (fn: any, ...args: any[]): any =>
  fn.length <= args.length ? fn(...args) : curry.bind(null, fn, ...args);
// const sum = (a, b, c) => a + b + c;
// curry(sum)(1)(2)(3); // 6
// curry(sum)(1, 2, 3); // 6
// curry(sum, 1)(2, 3); // 6
// curry(sum, 1)(2)(3); // 6
// curry(sum, 1, 2)(3); // 6
// curry(sum, 1, 2, 3); // 6

8. Memoize a function

export const memoize = (fn: any) =>
  (
    (cache = Object.create(null)) =>
    (arg: any) =>
      cache[arg] || (cache[arg] = fn(arg))
  )();
// Calculate Fibonacci numbers
// const fibo = memoize((n: number) => (n <= 2 ? 1 : fibo(n - 1) + fibo(n - 2)));
// fibo(1); // 1
// fibo(2); // 1
// fibo(3); // 2
// fibo(4); // 3
// fibo(5); // 5
// fibo(6); // 8

Math one liners ☝️

1. Calculate the angle of a line defined by two points

interface Point {
x: number;
y: number;
}

export const radiansAngle = (p1: Point, p2: Point): number => Math.atan2(p2.y - p1.y, p2.x - p1.x);
// radiansAngle({ x: 0, y: 0 }, { x: 0, y: 1 }); //
export const degreesAngle = (p1: Point, p2: Point): number => (Math.atan2(p2.y - p1.y, p2.x - p1.x) * 180) / Math.PI;
// degreesAngle({ x: 0, y: 0 }, { x: 0, y: 3 }); // 90

2. Calculate the distance between two points

interface Point {
  x: number;
  y: number;
}

export const distance = (p1: Point, p2: Point): number =>
  Math.sqrt(Math.pow(p2.x - p1.x, 2) + Math.pow(p2.y - p1.y, 2));
// distance({ x: 0, y: 0 }, { x: 0, y: 1 }); // 1

3. Calculate the linear interpolation between two numbers

export const lerp = (a: number, b: number, amount: number): number => (1 - amount) * a + amount * b;
// lerp(0, 1, 0.5); // 0.5

4. Calculate the midpoint between two points

interface Point {
  x: number;
  y: number;
}

export const midpoint = (p1: Point, p2: Point): number[] => [(p1.x + p2.x) / 2, (p1.y + p2.y) / 2];
// midpoint({ x: 0, y: 0 }, { x: 0, y: 1 }); // [0, 0.5]

5. Calculate the slope between two points

interface Point {
  x: number;
  y: number;
}

export const slope = (p1: Point, p2: Point): number => (p2.y - p1.y) / (p2.x - p1.x);
// slope({ x: 0, y: 0 }, { x: 0, y: 1 }); // 1

6. Calculate the perpendicular slope between two points

interface Point {
  x: number;
  y: number;
}

export const perpendicularSlope = (p1: Point, p2: Point): number => -1 / slope(p1, p2);
// perpendicularSlope({ x: 0, y: 0 }, { x: 0, y: 1 }); // -1

7. Check if a point is inside a rectangle

interface Point {
  x: number;
  y: number;
}

interface Rect {
  bottom: number;
  left: number;
  top: number;
  right: number;
}

export const isInside = (point: Point, rect: Rect): boolean =>
  point.x > rect.left && point.x < rect.right && point.y > rect.top && point.y < rect.bottom;

// isInside({ x: 0, y: 0 }, { left: 0, top: 0, right: 1, bottom: 1 }); // true

8. Check if a point is inside a circle

interface Point {
  x: number;
  y: number;
}

export const isInsideCircle = (point: Point, center: Point, radius: number): boolean => {
  const distance = Math.sqrt(Math.pow(point.x - center.x, 2) + Math.pow(point.y - center.y, 2));
  return distance < radius;
};

// isInsideCircle({ x: 0, y: 0 }, { x: 0, y: 0 }, 1); // true

9. Check if a rectangle contains other one

interface Rect {
  x1: number;
  x2: number;
  y1: number;
  y2: number;
}

export const contains = (a: Rect, b: Rect): boolean => a.x1 <= b.x1 && a.y1 <= b.y1 && a.x2 >= b.x2 && a.y2 >= b.y2;
// contains({ x1: 0, y1: 0, x2: 1, y2: 1 }, { x1: 0, y1: 0, x2: 1, y2: 1 }); // true

10. Check if a rectangle overlaps another one

interface Rect {
  x1: number;
  x2: number;
  y1: number;
  y2: number;
}

export const overlaps = (a: Rect, b: Rect): boolean => !(a.x2 < b.x1 || a.x1 > b.x2 || a.y2 < b.y1 || a.y1 > b.y2);
// overlaps({ x1: 0, y1: 0, x2: 1, y2: 1 }, { x1: 0, y1: 0, x2: 1, y2: 1 }); // true

11. Check if a rectangle is inside another one

interface Rect {
  x1: number;
  x2: number;
  y1: number;
  y2: number;
}

export const isInsideRect = (a: Rect, b: Rect): boolean => a.x1 >= b.x1 && a.y1 >= b.y1 && a.x2 <= b.x2 && a.y2 <= b.y2;
// isInsideRect({ x1: 0, y1: 0, x2: 1, y2: 1 }, { x1: 0, y1: 0, x2: 1, y2: 1 }); // true

12. Check if a rectangle is outside another one

interface Rect {
  x1: number;
  x2: number;
  y1: number;
  y2: number;
}

export const isOutsideRect = (a: Rect, b: Rect): boolean =>
  a.x1 <= b.x1 || a.y1 <= b.y1 || a.x2 >= b.x2 || a.y2 >= b.y2;
// isOutsideRect({ x1: 0, y1: 0, x2: 1, y2: 1 }, { x1: 0, y1: 0, x2: 1, y2: 1 }); // true

13. Check if a rectangle is touching another one

interface Rect {
  x1: number;
  x2: number;
  y1: number;
  y2: number;
}

export const isTouchingRect = (a: Rect, b: Rect): boolean =>
  a.x1 === b.x1 || a.x2 === b.x2 || a.y1 === b.y1 || a.y2 === b.y2;
// isTouchingRect({ x1: 0, y1: 0, x2: 1, y2: 1 }, { x1: 0, y1: 0, x2: 1, y2: 1 }); // true

14. Convert degrees to radians

export const degsToRads = (deg: number): number => (deg * Math.PI) / 180.0;
// degsToRads(90); // 1.5707963267948966

15. Convert radians to degrees

export const radsToDegs = (rad: number): number => (rad * 180.0) / Math.PI;
// radsToDegs(1.5707963267948966); // 90

16. Normalize the ratio of a number in a range

export const normalizeRatio = (value: number, min: number, max: number): number => (value - min) / (max - min);
// normalizeRatio(0, 0, 1); // 0

17. Round a number to the nearest multiple of a given value

export const roundNearest = (value: number, nearest: number): number => Math.round(value / nearest) * nearest;
// roundNearest(100, 30); // 90
// roundNearest(200, 30); // 210
// roundNearest(200, 40); // 200

18. Round a number to a given number of decimal places

export const roundToDecimal = (value: number, decimals: number): number => {
const factor = Math.pow(10, decimals);
return Math.round(value * factor) / factor;
};
// roundToDecimal(1.2345, 2); // 1.23

19. Calculate the average of arguments

export const average = (...args: number[]): number => args.reduce((a, b) => a + b) / args.length;
// average(1, 2, 3, 4); // 2.5

20.Calculate the division of arguments

export const division = (...args: number[]): number => args.reduce((a, b) => a / b);
// division(1, 2, 3, 4); // 0.04166666666666666

21. Calculate the factorial of a number

export const factorial = (n: number): number => (n <= 1 ? 1 : n * factorial(n - 1));
// factorial(2); // 2
// factorial(3); // 6
// factorial(4); // 24
// factorial(5); // 120
// factorial(6); // 720

22. Calculate the mod of collection index

export const mod = (a: number, b: number): number => ((a % b) + b) % b;
// mod(-1, 5); // 4
// mod(3, 5); // 3
// mod(6, 5); // 1

23. Calculate the remainder of division of arguments

export const remainder = (...args: number[]): number => args.reduce((a, b) => a % b);
// remainder(1, 2, 3, 4); // 1

24. Calculate the sum of arguments

export const sum = (...args: number[]): number => args.reduce((a, b) => a + b);
// sum(1, 2, 3, 4); // 10

25. Clamp a number between two values

export const clamp = (val: number, min: number = 0, max: number = 1): number => Math.max(min, Math.min(max, val));
// clamp(199, 10, 25); // 25

26. Compute the greatest common divisor between two numbers

export const gcd = (a: number, b: number): number => (b === 0 ? a : gcd(b, a % b));
// gcd(10, 15); // 5

27. Compute the least common multiple between two numbers

export const lcm = (a: number, b: number): number => (a * b) / gcd(a, b);
// lcm(10, 15); // 30

28. Compute the median of a collection of numbers

export const median = (...args: number[]): number => {
  const sorted = args.sort((a, b) => a - b);
  const mid = Math.floor(sorted.length / 2);
  return sorted.length % 2 !== 0 ? sorted[mid] : (sorted[mid - 1] + sorted[mid]) / 2;
};
// median(1, 2, 3, 4); // 2.5

29. Multiply arguments

export const mul = (...args: number[]): number => args.reduce((a, b) => a * b);
// mul(1, 2, 3, 4); // 24

30. Subtract arguments

export const subtract = (...args: number[]): number => args.reduce((a, b) => a - b);
// subtract(1, 2, 3, 4); // -8

Misc one liners ☝️

1. Check if the code is running in Jest

export const isRunningInJest: boolean = typeof process !== 'undefined' && process.env.JEST_WORKER_ID !== undefined;
// isRunningInJest; // true

2. Check if the code is running in NodeJS

export const isNode: boolean =
  typeof process !== 'undefined' && process.versions != null && process.versions.node != null;
// isNode; // true

3. Check if the code is running in the browser

export const isBrowser: boolean = typeof window === 'object' && typeof document === 'object';
// isBrowser; // true

4. Clear all cookies

export const clearCookies = (): void =>
  document.cookie
    .split(';')
    .forEach(
      (c) => (document.cookie = c.replace(/^ +/, '').replace(/=.*/, `=;expires=${new Date().toUTCString()};path=/`))
    );
// clearCookies();

5. Convert 3 digits color to 6 digits color

export const toFullHexColor = (color: string): string =>
  `#${(color.startsWith('#') ? color.slice(1) : color)
    .split('')
    .map((c) => `${c}${c}`)
    .join('')}`;
// toFullHexColor('123'); // '#112233'
// toFullHexColor('#123'); // '#112233'
// toFullHexColor('#abc'); // '#aabbcc'

6. Convert Celsius to Fahrenheit

export const celsiusToFahrenheit = (celsius: number): number => (celsius * 9) / 5 + 32;
// celsiusToFahrenheit(15); // 59
// celsiusToFahrenheit(0); // 32
// celsiusToFahrenheit(-20); // -4

7. Convert Fahrenheit to Celsius

export const fahrenheitToCelsius = (fahrenheit: number): number => ((fahrenheit - 32) * 5) / 9;
// fahrenheitToCelsius(59); // 15

8. Convert Celsius to Kelvin

export const celsiusToKelvin = (celsius: number): number => celsius + 273.15;
// celsiusToKelvin(15); // 298.15
// celsiusToKelvin(0); // 273.15

9. Convert Fahrenheit to Kelvin

export const fahrenheitToKelvin = (fahrenheit: number): number => ((fahrenheit - 32) * 5) / 9 + 273.15;
// fahrenheitToKelvin(59); // 298.15

10. Convert Kelvin to Celsius

export const kelvinToCelsius = (kelvin: number): number => kelvin - 273.15;
// kelvinToCelsius(298.15); // 15
// kelvinToCelsius(273.15); // 0

11. Convert Kelvin to Fahrenheit

export const kelvinToFahrenheit = (kelvin: number): number => (kelvin * 9) / 5 - 459.67;
// kelvinToFahrenheit(298.15); // 59
// kelvinToFahrenheit(273.15); // 32

12. Convert rgb color to hex

export const rgbToHex = (red: number, green: number, blue: number): string =>
  `#${[red, green, blue].map((v) => v.toString(16).padStart(2, '0')).join('')}`;
// rgbToHex(0, 255, 255); // '#00ffff'

13. Convert hex color to rgb

export const hexToRgb = (hex: string): [number, number, number] => {
  const [r, g, b] = hex
    .slice(1)
    .split('')
    .map((c) => parseInt(c + c, 16));
  return [r, g, b];
}; // hexToRgb('#00ffff'); // [0, 255, 255]

// Convert URL parameters to object
export const getUrlParams = (query: string): Record<string, string> =>
  Array.from(new URLSearchParams(query)).reduce(
    (p, [k, v]) => Object.assign({}, p, { [k]: p[k] ? (Array.isArray(p[k]) ? p[k] : [p[k]]).concat(v) : v }),
    {} as Record<string, string>
  );
// getUrlParams(location.search); // Get the parameters of the current URL
// getUrlParams('foo=Foo&bar=Bar'); // { foo: "Foo", bar: "Bar" }
// Duplicate key
// getUrlParams('foo=Foo&foo=Fuzz&bar=Bar'); // { foo: ["Foo", "Fuzz"], bar: "Bar" }

14. Convert object to URL parameters

export const toUrlParams = (obj: Record<string, string | string[]>): string => {
  const params = new URLSearchParams();
  Object.entries(obj).forEach(([k, v]) => {
    if (Array.isArray(v)) {
      v.forEach((val) => params.append(k, val));
    } else {
      params.append(k, v);
    }
  }),
    params.toString();
  return params.toString();
};
// toUrlParams({ foo: "Foo", bar: "Bar" }); // "foo=Foo&bar=Bar"

15. Decode a JWT token

export const decodeJwt = (token: string): Record<string, string> => {
  const [, payload] = token.split('.');
  return JSON.parse(atob(payload));
};
// decodeJwt('eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c');
// { sub: "1234567890", name: "John Doe", iat: 1516239022 }

16. Encode a JWT token

export const encodeJwt = (obj: Record<string, string>): string => {
  const payload = JSON.stringify(obj);
  const base64Payload = btoa(payload);
  const base64Header = btoa(JSON.stringify({ alg: 'none', typ: 'JWT' }));
  return `${base64Header}.${base64Payload}`;
};
// encodeJwt({ sub: "1234567890", name: "John Doe", iat: 1516239022 });
// "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ"

17. Detect dark mode

export const isDarkMode: boolean = window.matchMedia && window.matchMedia('(prefers-color-scheme: dark)').matches;
// isDarkMode; // true

18. Easing functions

export const linear = (t: number): number => t;

export const easeInQuad = (t: number): number => t * t;
export const easeOutQuad = (t: number): number => t * (2 - t);
export const easeInOutQuad = (t: number): number => (t < 0.5 ? 2 * t * t : -1 + (4 - 2 * t) * t);

export const easeInCubic = (t: number): number => t * t * t;
export const easeOutCubic = (t: number): number => --t * t * t + 1;
export const easeInOutCubic = (t: number): number =>
  t < 0.5 ? 4 * t * t * t : (t - 1) * (2 * t - 2) * (2 * t - 2) + 1;

export const easeInQuart = (t: number): number => t * t * t * t;
export const easeOutQuart = (t: number): number => 1 - --t * t * t * t;
export const easeInOutQuart = (t: number): number => (t < 0.5 ? 8 * t * t * t * t : 1 - 8 * --t * t * t * t);

export const easeInQuint = (t: number): number => t * t * t * t * t;
export const easeOutQuint = (t: number): number => 1 + --t * t * t * t * t;
export const easeInOutQuint = (t: number): number => (t < 0.5 ? 16 * t * t * t * t * t : 1 + 16 * --t * t * t * t * t);

export const easeInSine = (t: number): number => 1 + Math.sin((Math.PI / 2) * t - Math.PI / 2);
export const easeOutSine = (t: number): number => Math.sin((Math.PI / 2) * t);
export const easeInOutSine = (t: number): number => (1 + Math.sin(Math.PI * t - Math.PI / 2)) / 2;

export const easeInElastic = (t: number): number => (0.04 - 0.04 / t) * Math.sin(25 * t) + 1;
export const easeOutElastic = (t: number): number => ((0.04 * t) / --t) * Math.sin(25 * t);
export const easeInOutElastic = (t: number): number =>
  (t -= 0.5) < 0 ? (0.02 + 0.01 / t) * Math.sin(50 * t) : (0.02 - 0.01 / t) * Math.sin(50 * t) + 1;

19. Emulate a dice throw

export const throwdice = (): number => ~~(Math.random() * 6) + 1;
// throwdice(); // 4
// throwdice(); // 1
// throwdice(); // 6

20. Emulate a coin flip

export const flipcoin = (): boolean => Math.random() < 0.5;
// flipcoin(); // true

21. Encode a URL

export const encode = (url: string): string =>
  encodeURIComponent(url)
    .replace(/!/g, '%21')
    .replace(/~/g, '%7E')
    .replace(/\*/g, '%2A')
    .replace(/'/g, '%27')
    .replace(/\(/g, '%28')
    .replace(/\)/g, '%29')
    .replace(/%20/g, '+');
// encode('https://www.google.com/'); // 'https%3A%2F%2Fwww.google.com%2F'

22. Decode a URL

export const decode = (url: string): string => decodeURIComponent(url.replace(/\+/g, '%20'));
// decode('https%3A%2F%2Fwww.google.com%2F'); // 'https://www.google.com/'

23. Get the current URL

export const getUrl = (): string => window.location.href;
// getUrl(); // 'https://www.google.com/'

24. Get the first defined and non null argument

export const coalesce = (...args: any[]): any[] => args.find((item) => ![undefined, null].includes(item));
// coalesce(undefined, null, 'helloworld', NaN); // 'helloworld'

25. Get the value of a param from a URL

export const getParam = (url: string, param: string): string | null =>
  new URLSearchParams(new URL(url).search).get(param);
getParam('http://domain.com?message=hello', 'message'); // 'hello'

26. Get type of a variable in string

export const getTypeOf = (obj: any): string => (Object.prototype.toString.call(obj).match(/\[object (.*)\]/) as string[])[1];
// getTypeOf('hello world'); // String
// getTypeOf(1000); // Number
// getTypeOf(Infinity); // Number
// getTypeOf(true); // Boolean
// getTypeOf(Symbol()); // Symbol
// getTypeOf(null); // Null
// getTypeOf(undefined); // Undefined
// getTypeOf({}); // Object
// getTypeOf([]); // Array
// getTypeOf(/[a-z]/g); // RegExp
// getTypeOf(new Date(2021)); // Date
// getTypeOf(new Error()); // Error
// getTypeOf(function () {}); // Function
// getTypeOf((a, b) => a + b); // Function
// getTypeOf(async () => {}); // AsyncFunction
// getTypeOf(document); // HTMLDocument

27. Redirect the page to HTTPS if it is in HTTP

export const redirectHttps = (): string => (location.protocol === 'https:' ? '' : (location.protocol = 'https:'));

28. Run Promises in sequence

export const run = (promises: Promise<any>[]): Promise<any> =>
  promises.reduce((p, c) => p.then((rp) => c.then((rc) => [...rp, rc])), Promise.resolve([]));
// run(promises).then((results) => {
// // `results` is an array of promise results in the same order
// });

29. Run Promises in parallel

export const runParallel = (promises: Promise<any>[]): Promise<any> => Promise.all(promises);
// runParallel(promises).then((results) => {
// // `results` is an array of promise results in the same order
// });

30. Run Promises in parallel and return the results in the same order

export const runParallelOrder = (promises: Promise<any>[]): Promise<any> =>
  Promise.all(promises).then((results) => results.reduce((p, c) => [...p, c], []));
// runParallelOrder(promises).then((results) => {
// // `results` is an array of promise results in the same order
// });

31. Wait for an amount of time

export const wait = async (milliseconds: number) => new Promise((resolve) => setTimeout(resolve, milliseconds));
// wait(1000).then(() => console.log('done'));

32. Add an ordinal suffix to a number

export const addOrdinal = (n: number): string => `${n}${[, 'st', 'nd', 'rd'][(n % 100 >> 3) ^ 1 && n % 10] || 'th'}`;
// addOrdinal(1); // '1st'
// addOrdinal(2); // '2nd'
// addOrdinal(3); // '3rd'
// addOrdinal(11); // '11th'
// addOrdinal(12); // '13th'
// addOrdinal(13); // '13th'

33. Convert a number to equivalent characters

export const toChars = (n: number): string =>
  `${n >= 26 ? toChars(Math.floor(n / 26) - 1) : ''}${'ABCDEFGHIJKLMNOPQRSTUVWXYZ'[n % 26]}`;
// toChars(0); // A
// toChars(1); // B
// toChars(25); // Z

// toChars(26); // AA
// toChars(27); // AB
// toChars(51); // AZ

Objects one liners ☝️

1.Check if multiple objects are equal

export const isEqual = (...objects: object[]): boolean =>
  objects.every((obj) => JSON.stringify(obj) === JSON.stringify(objects[0]));
// isEqual({ foo: 'bar' }, { foo: 'bar' }); // true
// isEqual({ foo: 'bar' }, { bar: 'foo' }); // false

2. Extract values of a property from an array of objects

export const pluck = (objs: any[], property: any) => objs.map((obj) => obj[property]);
// pluck(
// [
// { name: 'John', age: 20 },
// { name: 'Smith', age: 25 },
// { name: 'Peter', age: 30 }
// ],
// 'name'
// ); // ['John', 'Smith', 'Peter']

3. Get the value at given path of an object

export const getValue = (path: string, obj: any) => path.split('.').reduce((acc, c) => acc && acc[c], obj);
// getValue('a.b', { a: { b: 'Hello World' } }); // 'Hello World';

4. Remove all null and undefined properties from an object

export const removeNullUndefined = (obj: Object) =>
  Object.fromEntries(Object.entries(obj).filter(([_, v]) => v != null));
// removeNullUndefined({
// foo: null,
// bar: undefined,
// fuzz: 42,
// }); // { fuzz: 42 }

5. Shallow clone an object

export const shallowCopy = (obj: Object): Object => ({ ...obj });

6. Sort an object by its properties

export const sort = (obj: any) =>
  Object.keys(obj)
    .sort()
    .reduce((p: any, c: string) => ((p[c] = obj[c]), p), {});
// const colors = {
// white: '#ffffff',
// black: '#000000',
// red: '#ff0000',
// green: '#008000',
// blue: '#0000ff',
// };
// sort(colors);
// {
// black: '#000000',
// blue: '#0000ff',
// green: '#008000',
// red: '#ff0000',
// white: '#ffffff',
// }

String one liners ☝️

1. Capitalize a string

export const capitalize = (str: string): string => `${str.charAt(0).toUpperCase()}${str.slice(1)}`;
// capitalize('hello world'); // 'Hello world'

2. Check if a path is relative

export const isRelative = (path: string): boolean => !/^([a-z]+:)?[\\/]/i.test(path);
// isRelative('/foo/bar/baz'); // false
// isRelative('C:\\foo\\bar\\baz'); // false
// isRelative('foo/bar/baz.txt'); // true
// isRelative('foo.md'); // true

3. Check if a string consists of a repeated character sequence

export const consistsRepeatedSubstring = (str: string): boolean => `${str}${str}`.indexOf(str, 1) !== str.length;
// consistsRepeatedSubstring('aa'); // true
// consistsRepeatedSubstring('aaa'); // true
// consistsRepeatedSubstring('ababab'); // true
// consistsRepeatedSubstring('abc'); // false

4. Check if a URL is absolute

export const isAbsoluteUrl = (url: string): boolean => /^[a-z][a-z0-9+.-]*:/.test(url);
// isAbsoluteUrl('https://1loc.dev'); // true
// isAbsoluteUrl('https://1loc.dev/foo/bar'); // true
// isAbsoluteUrl('1loc.dev'); // false
// isAbsoluteUrl('//1loc.dev'); // false

5. Check if two strings are anagram

export const areAnagram = (str1: string, str2: string): boolean =>
  str1.toLowerCase().split('').sort().join('') === str2.toLowerCase().split('').sort().join('');
// areAnagram('listen', 'silent'); // true
// areAnagram('they see', 'the eyes'); // true
// areAnagram('node', 'deno'); // true

6. Convert a base64 encoded string to an uint8 array

export const base64ToUint8 = (str: string): Uint8Array => Uint8Array.from(atob(str), (c) => c.charCodeAt(0));
// base64ToUint8('SGVsbG8gV29ybGQ='); // Uint8Array [104, 101, 108, 108, 111, 32, 119, 111, 114, 108, 100]

7. Convert a letter to associate emoji

export const letterToEmoji = (c: string): string => String.fromCodePoint(c.toLowerCase().charCodeAt(0) + 127365);
// letterToEmoji('a'); // 🇦
// letterToEmoji('b'); // 🇧

8. Convert a string to camelCase

export const toCamelCase = (str: string): string =>
str.trim().replace(/[-_\s]+(.)?/g, (_, c) => (c ? c.toUpperCase() : ''));
// toCamelCase('background-color'); // backgroundColor
// toCamelCase('-webkit-scrollbar-thumb'); // WebkitScrollbarThumb
// toCamelCase('_hello_world'); // HelloWorld
// toCamelCase('hello_world'); // helloWorld

9. Convert a string to PascalCase

export const toPascalCase = (str: string): string =>
  (str.match(/[a-zA-Z0-9]+/g) || []).map((w) => `${w.charAt(0).toUpperCase()}${w.slice(1)}`).join('');
// toPascalCase('hello world'); // 'HelloWorld'
// toPascalCase('hello.world'); // 'HelloWorld'
// toPascalCase('foo_bar-baz'); // FooBarBaz

10. Convert a string to URL slug

export const slugify = (str: string): string =>
  str
    .toLowerCase()
    .replace(/\s+/g, '-')
    .replace(/[^\w-]+/g, '');
// slugify('Chapter One: Once upon a time...'); // 'chapter-one-once-upon-a-time'

11. Convert a Windows file path to Unix path

export const toUnixPath = (path: string): string => path.replace(/[\\/]+/g, '/').replace(/^([a-zA-Z]+:|\.\/)/, '');
// toUnixPath('./foo/bar/baz'); // foo/bar/baz
// toUnixPath('C:\\foo\\bar\\baz'); // /foo/bar/baz

12. Convert an uint8 array to a base64 encoded string

export const uint8ToBase64 = (arr: Uint8Array): string => Buffer.from(arr).toString('base64');
// uint8ToBase64(Uint8Array.from([104, 101, 108, 108, 111, 32, 119, 111, 114, 108, 100])); // 'SGVsbG8gV29ybGQ='

13. Convert camelCase to kebab-case and vice versa

export const kebabToCamel = (str: string): string => str.replace(/-./g, (m) => m.toUpperCase()[1]);
// kebabToCamel('background-color'); // 'backgroundColor'

export const camelToKebab = (str: string): string => str.replace(/([a-z0-9])([A-Z])/g, '$1-$2').toLowerCase();
// camelToKebab('backgroundColor'); // 'background-color'

14. Convert snake_case to camelCase

export const snakeToCamel = (str: string): string =>
  str.toLowerCase().replace(/(_\w)/g, (m) => m.toUpperCase().substr(1));
// snakeToCamel('HELLO_world'); // 'helloWorld'

15. Count the occurrences of a character in a string

export const countOccurrences = (str: string, char: string): number => [...str].filter((item) => item === char).length;
// countOccurrences('a.b.c.d.e', '.'); // 4

16. Format a string

export const format = (str: string, ...vals: string[]): string =>
  vals.reduce((s, v, i) => s.replace(new RegExp('\\{' + i + '\\}', 'g'), v), str);
// const template = 'My name is {0} and I am {1} years old';

// format(template, 'John', '30');
// // My name is John and I am 30 years old

// format(template, 'Jane', '20');
// // My name is Jane and I am 20 years old

17. Generate a hash of a string

export const hash = (str: string): number =>
  str.split('').reduce((prev, curr) => (Math.imul(31, prev) + curr.charCodeAt(0)) | 0, 0);
// hash('hello'); // 99162322

18. Get the base URL without any parameters

export const baseUrl = (url: string): string => url.split('?')[0];
// baseUrl('https://domain.com/path/sub/path?foo=bar&hello=world'); // 'https://domain.com/path/sub/path'

19. Get the number of a character in a string

export const characterCount = (str: string, char: string): number => str.split(char).length - 1;
// characterCount('192.168.1.1', '.'); // 3
// characterCount('star wars', 's'); // 2

20. Replace the first given number of characters of a string with another character

export const mask = (str: string, num: number, mask: string): string =>
  `${str}`.slice(num).padStart(`${str}`.length, mask);
// mask(1234567890, 3, '*'); // ***4567890

21. Uppercase the first character of each word in a string

export const uppercaseWords = (str: string): string => str.replace(/^(.)|\s+(.)/g, (c) => c.toUpperCase());
// uppercaseWords('hello world'); // 'Hello World'

Desplegando Bot de Telegram a AWS ECS con AWS Copilot [paso a paso] para principiantes

Christian Prado Ciokler — Thu, 28 Oct 2021 20:18:47 +0000

Copilot es una herramienta joven para crear e implementar servicios en contenedores sin manejar todos los problemas de configuración de ECS, EC2 y Fargate. Tal vez haya una mejor manera de implementar este tipo de proyecto, pero esta es una mas, quizás a alguien le resulte de útil.

🙏 Espero que les sea de ayuda 👍 este articulo, así que vamos al grano. 🚀

Tabla de contenido

El Stack
Instalando Node
Instalando AWS CLI
Instalando Copilot Cli
Instalando Docker
Configurando el proyecto
Creando el bot
Escribiendo código
Probando el código
Configurando dockerfile
Desplegando a ECS con Copilot Cli
Refactorizando y actualizando
The End

El Stack ☝️

Para este proyecto vamos a utilizar las siguientes herramientas, no se preocupen si no saben cómo utilizarlas, le dejo los enlaces de la documentación a continuación. De todos modos, esta es una guía paso a paso hasta el final.

OS: Windows -debe funcionar con otros sistemas-
Node docs Instalación
AWS CLI v2 docs Instalación
Copilot Cli docs Instalación
Docker docs Instalación
Telegraf docs Instalación
Binance API docs
Axios docs

Instalando Node ☝️

Primero, instalamos Node, no hay mucho que decir al respecto, solo sigan este enlace aquí para descargar Node y el instalador los guiará a través del proceso. En el momento en que se crea esta publicación, estamos usando la versión 16.11.0.

Instalando AWS CLI ☝️

En primer lugar, debemos tener una cuenta de AWS, por lo que si no la tienen pueden crear una aquí.

Una vez creada la cuenta instalamos AWS CLI v2 y revisamos si funciona con el comando aws help

Con todo en orden, el siguiente paso es configurar las credenciales de AWS. Entonces necesitamos crear claves de acceso para un usuario de IAM.

Inicie sesión en la Consola de administración de AWS y abra la consola de IAM aquí.
En el panel de navegación, escoge Users.
Elija el nombre del usuario cuyas claves de acceso desea crear y luego selecciona Security credentials .
En la sección Access keys , selecciona Create access key.
Para ver el nuevo par de claves de acceso, elija Show . No tendrá acceso a la clave secreta nuevamente después de que se cierre este cuadro de diálogo. Sus credenciales se verán así:
Access key ID: AKIAIOSFODNN7EXAMPLE
Secret access key: wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
Para descargar el par de claves, selecciona Download .csv file. Guarde las llaves en un lugar seguro. No tendrá acceso a la clave secreta nuevamente después de que se cierre este cuadro de diálogo.
Mantenga las claves confidenciales para proteger su cuenta de AWS y nunca las envíe por correo electrónico. No las comparta fuera de su organización, incluso si una consulta parece provenir de AWS o Amazon.com. Nadie que represente legítimamente a Amazon jamás le pedirá su clave secreta.
Después de descargar el archivo .csv, elija Close. Cuando crea una clave de acceso, el par de claves está activo de forma predeterminada y puede usar el par de inmediato.
Para agregar las credenciales a la AWS CLI escribimos el comando aws configure --profile myprofilename en la terminal y seguimos los pasos.
AWS Access Key ID [None]: AKIAI44QH8DHBEXAMPLE
AWS Secret Access Key [None]: je7MtGbClwBF/EXAMPLEKEY
Default region name [None]: us-east-1
Default output format [None]: json

Eso es todo, ¡haz configurado con éxito AWS CLI!

Instalando Copilot Cli ☝️

Las instrucciones para la instalación están aquí, una vez que haya terminado escriba copilot --help en su terminal si todo funciona como se supone,! Felicidades, tu pc es más inteligente que la mía, si tuviste un error no te preocupes yo tuve el mismo problema. Así es como puede solucionarlo.

Recuerde esta solución fue probada en el sistema operativo Windows.

Busque los archivos instalados y elimínelos, copilot.exe, copilot.asc y ecs-cli.asc.
Vuelva a instalarlos usando la terminal como administrador pero en esta carpeta.

Invoke-WebRequest -OutFile 'C:\Program Files\Amazon\Copilot\copilot.exe' https://github.com/aws/copilot-cli/releases/latest/download/copilot-windows.exe

Invoke-WebRequest -OutFile 'C:\Program Files\Amazon\Copilot\copilot.asc' https://github.com/aws/copilot-cli/releases/latest/download/copilot-windows.exe.asc

Invoke-WebRequest -OutFile 'C:\Program Files\Amazon\Copilot\ecs-cli.asc' https://github.com/aws/copilot-cli/releases/latest/download/copilot-windows.exe

Presione Win + R y escriba esto rundll32.exe sysdm.cpl, EditEnvironmentVariables, se abrirá su panel de variables de entorno.
Vaya a las variables del sistema, seleccione path y haga clic en editar, agregue una nueva ruta C:\Program Files\Amazon\Copilot o la ruta donde está el archivo copilot.exe.
Guarde los cambios y reinicie.

Escribe el comando copilot --help en tu terminal y debería funcionar.

Instalando Docker ☝️

Descargue Docker aquí y siga las instrucciones.

Antes de instalar el backend de Docker Desktop WSL 2, debe completar los siguientes pasos:

Instale Windows 10, versión 1903 o superior, o Windows 11.
Habilite la función WSL 2 en Windows. Para obtener instrucciones detalladas, consulte la documentación de Microsoft.
Descargue e instale el paquete de actualización del kernel de Linux.

Configurando el proyecto ☝️

Crea una carpeta y dale un nombre de tu elección, el mío será crypto-bot-app, abre tu carpeta en tu IDE y escribe npm init -y

Agrega los paquetes. Escribe en la terminal npm i telegraf axios
¡¡¡Todo listo!!!

Creando el bot ☝️

Abra su aplicación de Telegram y busque el BotFather e inicie el bot.
Escribe el comando /newbot y dale un nombre, el mío será crypto-bot y el nombre de usuario crptobot
Debería recibir un token como este 2098237194:AAH9QoFokuBOn0IqES0IGJdJ_AR-tySMOX4, guárdelo para más tarde.

¡Creaste tu primer bot !! ¡¡Felicitaciones !!, ahora vamos a agregarle código.

Escribiendo código ☝️

Cree un archivo index.js en la carpeta del proyecto donde vamos a poner este código.

const {Telegraf} = require('telegraf');
const axios = require('axios');

const bot = new Telegraf('2098237194:AAH9QoFokuBOn0IqES0IGJdJ_AR-tySMOX4');//your token

// START-----------------------------------------------
bot.start(async (ctx) => {
  await ctx.reply(`Hi ${ctx.from.first_name}`);
  await ctx.reply(`I still under development but you can use me to get the latest price of a cryptocurrency`);
  await ctx.reply(`For example to know the price of an specific crypto write the command /price and the symbol of the cryptocurrency`);
  await ctx.reply(`/price btc`);
});

// COMMANDS===============================================================
bot.command(['price', 'Price', 'PRICE'], (ctx)=> {
    try {
        const ticker = ctx.message.text.toLowerCase().split('/price ')[1].toUpperCase();
        const {data} = await axios.get(`https://api.binance.com/api/v3/ticker/price?symbol=${ticker}USDT`);
        ctx.reply(ticker+': '+data.price+' USDT');
      } catch (error) {
        ctx.reply('Some error occurred in your request, please try again');
      }
});

bot.launch();

Probando el código ☝️

Antes de correr el bot, agreguemos el siguiente fragmento de código a nuestro package.json.

 "scripts": {
    "start": "node index.js", //here
    "test": "test",  
},

Ahora ejecute el comando npm start, vaya a telegram, abra su bot y escriba /start o /price btc

Una vez que reciba la respuesta esperada, podemos continuar este viaje.

Configurando dockerfile ☝️

Crea un archivo en el directorio de su proyecto y asígnele el nombre Dockerfile, agregue este código de configuración.

FROM node:16.9.1

WORKDIR /app

COPY package*.json ./

RUN npm install

COPY . .

EXPOSE 80

CMD ["npm","start"]

Además, cree un archivo con el nombre .dockerignore y agregue este:

copilot
node_modules

Desplegando a ECS con Copilot Cli ☝️

Ahora que tenemos el dockerfile configurado correctamente, vamos a subir el bot en ECS para que funcione 24 horas al día, 7 días a la semana.

Escriba el comando copilot init.
Nombre de la aplicación, crypto-bot-app.
Elegimos la carga de trabajo, en mi caso Backend Service.
Nombre el servicio de backend como bot-main-service.
Despliegue la aplicación con el comando copilot app deploy.

Refactorizando y actualizando ☝️

En este punto, podemos hacer una refactorización para optimizar nuestro código. Primero, crearemos una carpeta "src" con un archivo javascript llamado "bot-functions.js" y agregaremos este código.

bot-functions.js

const axios = require('axios');

module.exports = functions = {
  start_message: async (ctx) => {
    await ctx.reply(`Hi ${ctx.from.first_name}`);
      await ctx.reply(`I still under development but you can use me to get the latest price of a cryptocurrency`);
      await ctx.reply(`For example to know the price of an specific crypto write the command /price and the symbol of the cryptocurrency`);
      await ctx.reply(`/price btc`);
  },
  getCryptocurrencyPrice: async (ctx) => {
    try {
      const ticker = ctx.message.text.toLowerCase().split('/price ')[1].toUpperCase();
      const {data} = await axios.get(`https://api.binance.com/api/v3/ticker/price?symbol=${ticker}USDT`);
      ctx.reply(ticker+': '+data.price+' USDT');
    } catch (error) {
      ctx.reply('Some error occurred in your request, please try again');
    }
  },
};

luego vaya a index.js y realice algunos cambios.

index.js

const {Telegraf} = require('telegraf');
const functions = require('./src/bot-functions.js');

const bot = new Telegraf('2098237194:AAH9QoFokuBOn0IqES0IGJdJ_AR-tySMOX4');//your token

bot.start((ctx) => functions.start_message(ctx));

bot.command(['price', 'Price', 'PRICE'], (ctx)=> functions.getCryptocurrencyPrice(ctx));

bot.launch();

Ahora probamos que todo está funcionando correctamente, agregamos los cambios con el comando copilot app deploy.

The End ☝️

Ten en cuenta que este es un proyecto de desarrollo con fines educativos, en el mundo real debe almacenar tokens e información importante en variables del entorno, y todas las buenas prácticas que el trabajo exige. Si te gusto, dale un pulgar arriba: +1: y compártelo.

hasta la próxima publicación ...

Deploying a Telegram Bot to AWS ECS with AWS Copilot. [Step by step] for absolut beginners.

Christian Prado Ciokler — Wed, 20 Oct 2021 13:29:00 +0000

The purpose of this project is to share my experience and hope to be of help to someone. Copilot is a young tool for creating and deploying containerized services without handling all the configuration troubles of ECS, EC2, and Fargate. Maybe there is a better way to deploy this kind of project out there but please humor me, we are having fun and trying new things.

🙏 Hope you like 👍 this post and let's get down to business. 🚀

Table of content

The Stack
Installing Node
Installing AWS CLI
Installing Copilot Cli
Installing Docker
Setting up the project
Creating the Bot
Let’s code
Testing the Code
Configuring dockerfile
Deploying to ECS with Copilot Cli
Making some refactoring & updating
The End

The Stack ☝️

For this project we are going to use the following tools, don’t worry if you don’t know how to use them I’ll leave you the documentation links down below. Anyhow, I would guide you step by step all the way.

OS: Windows -should work on others OS as well-
Node docs installation
AWS CLI v2 docs installation
Copilot Cli docs installation
Docker docs installation
Telegraf docs installation
Binance API docs
Axios docs

Installing Node ☝️

First, we install node, there is not much to say about it just follow this link here to download Node and the installer will guide you through the process. At the moment this post is been created we are using version 16.11.0.

Installing AWS CLI ☝️

First, we need to have an AWS account, so if you don’t have one get down to it.

Once you have the account created we install AWS CLI v2 and check if it is working with the command aws help

With everything in order, the next step is to configure AWS credentials. So we need to create access keys for an IAM user

Sign in to the AWS Management Console and open the IAM console at here.
On the navigation pane, choose Users.
Choose the name of the user whose access keys you want to create, and then choose the Security credentials tab.
In the Access keys section, choose Create access key.
To view the new access key pair, choose Show. You will not have access to the secret access key again after this dialog box closes. Your credentials will look something like this:
Access key ID: AKIAIOSFODNN7EXAMPLE
Secret access key: wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
To download the key pair, choose Download .csv file. Store the keys in a secure location. You will not have access to the secret access key again after this dialog box closes.
Keep the keys confidential to protect your AWS account and never email them. Do not share them outside your organization, even if an inquiry appears to come from AWS or Amazon.com. No one who legitimately represents Amazon will ever ask you for your secret key.
After you download the .csv file, choose Close. When you create an access key, the key pair is active by default, and you can use the pair right away.

To add the credentials to AWS CLI we write the command aws configure --profile myprofilename in the terminal and follow the steps.

AWS Access Key ID [None]: AKIAI44QH8DHBEXAMPLE
AWS Secret Access Key [None]: je7MtGbClwBF/EXAMPLEKEY
Default region name [None]: us-east-1
Default output format [None]: json

That’s it, know you have successfully set up AWS CLI !!!!

Installing Copilot Cli ☝️

The instructions for the installation are here, once you are done write copilot --help in your terminal if everything works as it supposes to,!Congratulations, your pc is smarter than mine, if you had an error don’t worry I had the same problem. Here is how you can fix it.

Remember this solution I only tested on Windows OS.

Find the installed files and delete them, copilot.exe, copilot.asc, and ecs-cli.asc.
Install them again using the terminal as administrator but in this folder.

Invoke-WebRequest -OutFile 'C:\Program Files\Amazon\Copilot\copilot.exe' https://github.com/aws/copilot-cli/releases/latest/download/copilot-windows.exe

Invoke-WebRequest -OutFile 'C:\Program Files\Amazon\Copilot\copilot.asc' https://github.com/aws/copilot-cli/releases/latest/download/copilot-windows.exe.asc

Invoke-WebRequest -OutFile 'C:\Program Files\Amazon\Copilot\ecs-cli.asc' https://github.com/aws/copilot-cli/releases/latest/download/copilot-windows.exe

Type Win + R and write this rundll32.exe sysdm.cpl,EditEnvironmentVariables, it will open your environment variables panel.
Go to system variables, select path and click edit, add a new path C:\Program Files\Amazon\Copilot or the path where the copilot.exe file is.
Save the changes and restart.

Write the command copilot --help in your terminal and it should work.

Installing Docker ☝️

Download docker here and follow the instructions.

Before you install the Docker Desktop WSL 2 backend, you must complete the following steps:

Install Windows 10, version 1903 or higher, or Windows 11.
Enable WSL 2 feature on Windows. For detailed instructions, refer to the Microsoft documentation.
Download and install the Linux kernel update package.

Setting up the project ☝️

Create a folder a give it a name of your choice, mine will be crypto-bot-app, open your folder on your IDE and write npm init -y

Now we add the packages. Write on the terminal npm i telegraf axios
All set!!!

Creating the bot ☝️

Open your Telegram app and search for the BotFather and start the bot.
Write the command /newbot and give it a name, mine will be crypto-bot and username crptobot
You should receive a token like this 2098237194:AAH9QoFokuBOn0IqES0IGJdJ_AR-tySMOX4, save it for later.

You created your first bot !!congratulation!!, now let add some code to it.

Let’s code ☝️

Create an index.js file on the project folder where we are going to put this code.

const {Telegraf} = require('telegraf');
const axios = require('axios');

const bot = new Telegraf('2098237194:AAH9QoFokuBOn0IqES0IGJdJ_AR-tySMOX4');//your token

// START-----------------------------------------------
bot.start(async (ctx) => {
  await ctx.reply(`Hi ${ctx.from.first_name}`);
  await ctx.reply(`I still under development but you can use me to get the latest price of a cryptocurrency`);
  await ctx.reply(`For example to know the price of an specific crypto write the command /price and the symbol of the cryptocurrency`);
  await ctx.reply(`/price btc`);
});

// COMMANDS===============================================================
bot.command(['price', 'Price', 'PRICE'], (ctx)=> {
    try {
        const ticker = ctx.message.text.toLowerCase().split('/price ')[1].toUpperCase();
        const {data} = await axios.get(`https://api.binance.com/api/v3/ticker/price?symbol=${ticker}USDT`);
        ctx.reply(ticker+': '+data.price+' USDT');
      } catch (error) {
        ctx.reply('Some error occurred in your request, please try again');
      }
});

bot.launch();

Testing the code ☝️

Before initiating, the code let's add the following piece of code to our package.json

 "scripts": {
    "start": "node index.js", //here
    "test": "test",  
},

Now run the command npm start, go to telegram, open your bot and type /start or /price btc

Once you receive the expected response we may continue this journey.

Configuring dockerfile ☝️

Create a file in your project directory and name it Dockerfile, add this configuration code

FROM node:16.9.1

WORKDIR /app

COPY package*.json ./

RUN npm install

COPY . .

EXPOSE 80

CMD ["npm","start"]

Also, create a file with the name .dockerignore and add this:

copilot
node_modules

Deploying to ECS with Copilot Cli ☝️

Now that we have the dockerfile configured correctly, we are going to deploy the bot to ECS to work 24/7.

Write the command copilot init.
Name de app, I'll use crypto-bot-app.
We choose the workload, in my case Backend Service.
Name backend service as bot-main-service.
Deploy the app with the command copilot app deploy.

Making some refactoring ☝️

At this point, we can make some refactoring to optimize our code. First, we are going to create a folder "src" with a javascript file named "bot-functions.js" and add this code.

bot-functions.js

const axios = require('axios');

module.exports = functions = {
  start_message: async (ctx) => {
    await ctx.reply(`Hi ${ctx.from.first_name}`);
      await ctx.reply(`I still under development but you can use me to get the latest price of a cryptocurrency`);
      await ctx.reply(`For example to know the price of an specific crypto write the command /price and the symbol of the cryptocurrency`);
      await ctx.reply(`/price btc`);
  },
  getCryptocurrencyPrice: async (ctx) => {
    try {
      const ticker = ctx.message.text.toLowerCase().split('/price ')[1].toUpperCase();
      const {data} = await axios.get(`https://api.binance.com/api/v3/ticker/price?symbol=${ticker}USDT`);
      ctx.reply(ticker+': '+data.price+' USDT');
    } catch (error) {
      ctx.reply('Some error occurred in your request, please try again');
    }
  },
};

then go to index.js and make some changes to it.

index.js

const {Telegraf} = require('telegraf');
const functions = require('./src/bot-functions.js');

const bot = new Telegraf('2098237194:AAH9QoFokuBOn0IqES0IGJdJ_AR-tySMOX4');//your token

bot.start((ctx) => functions.start_message(ctx));

bot.command(['price', 'Price', 'PRICE'], (ctx)=> functions.getCryptocurrencyPrice(ctx));

bot.launch();

Now we test that everything is working correctly, we add the changes with the command copilot app deploy.

The End ☝️

Keep in mind that this is a dev project for educational purposes, in the real world you should storage tokens and important information on environment variables, and all the good practices that the job demands. If you like it, give a thumbs-up 👍 and share it.

to the next post...