Category: Development

Efficient and Cost-effective Content Delivery: Unlocking the Potential of GitHub Repositories with jsDelivr as a CDN

November 22nd, 2023
Reading Time: 3 minutes
A CDN, or Content Delivery Network, is a distributed network of servers located around the world that helps deliver website content, such as images, videos, scripts, and stylesheets, to users more efficiently. It improves website performance by reducing latency, optimizing file delivery, and increasing availability. CDNs store cached copies of files closer to users, resulting in faster loading times, reduced server load, and improved overall user experience.

jsDelivr is a popular free CDN for open-source files that helps developers improve the performance and reliability of their websites or web applications. It allows you to easily load and deliver various files, such as JavaScript libraries, CSS stylesheets, and images, to your users from a distributed network of servers. jsDelivr also offers features like automatic compression, file optimization, and caching, further enhancing the distribution performance. This includes minification of JavaScript and CSS files, as well as image compression. jsDelivr provides HTTPS support by default, ensuring that files served through the CDN are delivered securely.

One of the notable features of jsDelivr is its ability to serve files directly from GitHub repositories. This means that you can use a GitHub repository as a CDN, making it easy to host and distribute your project files. It allows you to specify file versions using GitHub release tags or commit hashes. This enables you to control which version of a file is served, providing better control over your project dependencies. By leveraging jsDelivr, you can easily eliminate the need for setting up and managing a separate CDN infrastructure, making it a convenient solution for developers. It’s a cost-effective approach. GitHub provides free hosting for open-source repositories, allowing you to serve your files without incurring any additional costs for hosting and distribution using jsDelivr CDN.

How to use a GitHub repository as a CDN with jsDelivr

Let’s say you have the following GitHub URL:
```
https://github.com/<username>/<repository>/blob/<branch>/<some_sub_folder>/<file>.js
```
To distribute that file through the jsDelivr CDN you have to convert the URL to:
```
https://cdn.jsdelivr.net/gh/<username>/<repo>@<branch>/<some_sub_folder>/<file>.js
```
The above URL is not recommended for production environments because the code from that branch may change, especially if it is the main branch. Rather than <branch> it’s encouraged to use <version> thus:
```
https://github.com/<username>/<repository>/blob/<version>/<some_sub_folder>/<file>.js
```
The CDN version will be:
```
https://cdn.jsdelivr.net/gh/<username>/<repo>@<version>/<some_sub_folder>/<file>.js
```
Eventually you can use also @latest in the CDN URL. This option is not recommended for production environments since the fallback will be the default branch if there are not tagged releases which makes unpredictable.
```
https://cdn.jsdelivr.net/gh/<username>/<repo>@latest/<some_sub_folder>/<file>.js
```
It’s important to note that jsDelivr is primarily designed for serving smaller files, such as JavaScript libraries, CSS stylesheets. At the moment of writing this posts, the maximum size allowed is 20MB

Optionally, you may generate the URLs from this tool provided by jsDelivr itself: https://www.jsdelivr.com/github

A tool provided by jsDelivr to generate CDN links from GitGub URLs

How to purge a file from jsDelivr CDN

Static Versions and commit hashes are cached forever. Versions (including last) are cached during 7 days and branches 12 hours.

jsDelivr provides an easy way to purge a file from its CDN. Just go to https://www.jsdelivr.com/tools/purge and paste the URL you want. It will be generated again once the URL is requested.

A tool provided by jsDelivr to pure URLs from the CDN

The purge process might take a few moments to complete, depending on the number of files you have requested to be cleared from the cache. Once the purge is complete, the cache for the specified files will be cleared, and subsequent requests for those files will retrieve the latest version from your GitHub repository.

Minification support in jsDelivr

Minification is the process of reducing the size of files, such as JavaScript, CSS, or SVG, by removing unnecessary characters, spaces, line breaks, and comments. This optimization technique helps to improve the performance of websites and web applications by reducing the file size and thereby enabling faster downloads and improved loading times. Minification does not change the functionality of the code but increases its efficiency, making it easier and faster for browsers to interpret and execute.

jsDelivr provides a easy-to-use way to generate the min version. Just add .min to any JS/CSS/SVG file to get a minified version. From the URL we used before, this is how it looks like with minification.
```
https://cdn.jsdelivr.net/gh/<username>/<repo>@<branch>/<some_sub_folder>/<file>.min.js
```
Documentation

jsDelivr provides comprehensive documentation to help developers effectively utilize its features and functionalities. It includes examples, explanations of common scenarios to assist developers in using jsDelivr effectively. Access to the jsDelivr documentation at https://www.jsdelivr.com/documentation. It is a valuable resource for understanding the capabilities of jsDelivr and how to integrate it into your projects successfully.

November 9, 2023What is caching in a few words?
September 25, 2023What is WordPress?
September 23, 2023What is Dreamforce?
September 22, 2023What is tech debt in software engineering?
September 19, 2023What about Salesforce?
September 18, 2023What is Cloudinary?
httpbin.org: endpoints for testing

November 20th, 2023
Reading Time: 2 minutes
httpbin.org is a popular and free web service that provides various HTTP (Hypertext Transfer Protocol) endpoints for testing and debugging. It is primarily used by developers to simulate different HTTP request and response scenarios. With the help of httpbin.org, developers can experiment with different HTTP methods, headers, status codes, and request/response bodies. It can be particularly useful for API testing and development, allowing developers to inspect and analyze the details of the requests they send and the responses they receive. Overall, httpbin.org serves as a valuable tool for developers to gain better insights into HTTP interactions and troubleshoot any issues that may arise.

httpbin.org endpoints are designed to be easy to use. They provide a straightforward way for developers to simulate and test various HTTP scenarios. The endpoints are well-documented, allowing developers to quickly understand how to use them. By making HTTP requests to different endpoints, developers can easily experiment with different HTTP methods, headers, status codes, and request/response bodies. The responses from httpbin.org provide detailed information, such as headers, origin, and URL, helping developers gain insights into the interactions. Whether you’re testing APIs or debugging HTTP-related issues, httpbin.org offers a user-friendly and accessible platform for developers.

The most straightforward request it can be done is a simple GET to https://httpbin.org/get

Response:

Or you can try curl
```
curl -X GET "https://httpbin.org/get" -H "accept: application/json"
```
Response:
```
{
  "args": {}, 
  "headers": {
    "Accept": "application/json", 
    "Host": "httpbin.org", 
    "User-Agent": "curl/8.1.2", 
    "X-Amzn-Trace-Id": "Root=1-655b92c5-7ef61ccf7cf91fdc6a879001"
  }, 
  "origin": "xxx.xxx.xxx.xxx", 
  "url": "https://httpbin.org/get"
}
```
Overall, HTTPbin.org acts as a powerful tool for developers to gain insights into HTTP interactions, validate API behavior, and resolve any issues that may arise.

See more at https://httpbin.org/

November 22, 2023Efficient and Cost-effective Content Delivery: Unlocking the Potential of GitHub Repositories with jsDelivr as a CDN
November 15, 2023Salesforce Flows have this little big drawback
November 10, 2023How to publish Salesforce platform events from Salesforce API from Node.js
November 9, 2023What is caching in a few words?
November 8, 2023Different ways to use for loops in Node.js
November 7, 2023What are AWS Lambda Functions?
Salesforce Flows have this little big drawback

November 15th, 2023

Reading Time: 2 minutes
Salesforce Flows are a declarative automation tool in the Salesforce platform that allows users to build and execute business processes without writing code. With Flows, you can visually design and configure a sequence of screens, forms, and logic to guide users through different steps and automate various tasks.

Flows are built using a drag-and-drop interface, making them accessible to both developers and non-developers. They provide a way to streamline and automate complex business processes, such as creating records, updating fields, sending emails, initiating approvals, and interacting with external systems.

Flows have a variety of use cases, including building guided customer experiences, automating approvals and workflows, onboarding new employees, managing data updates, and more. They can be triggered by user actions, such as clicking a button or submitting a form, or by system events, such as record creation or modification.

Salesforce Flows offer a powerful alternative to traditional coding with Apex, allowing users to build scalable and customizable solutions. By leveraging Flows, organizations can improve productivity, enhance the user experience, and automate business processes without the need for extensive coding knowledge.

But it’s not perfect…

Salesforce Flows have several drawbacks that you should consider:

Complexity: While Salesforce Flows provide a visual interface for building business processes, they can still be complex to design and configure. Complex flows can be harder to understand, troubleshoot, and maintain, especially for users with limited technical expertise.

Limited functionality: Although Salesforce Flows offer a wide range of features, they may not cover all advanced requirements or complex business logic. Customization options are more limited compared to Apex code, which could restrict the level of customization you can achieve.

Performance: Flow execution can be slower compared to plain Apex code execution. If you have performance-sensitive processes or need to process a large volume of records, you might face performance challenges with Flows.

And the most important drawback…

Lack of visibility: Unlike Apex unit tests, Flow tests do not provide code coverage metrics. This makes it challenging to gauge the effectiveness of test coverage and identify areas that require additional testing effort. Even tough it is possible to create Apex unit tests to make sure our Salesforce Flows work, at the moment of writing this post, coverage it is not required before deploying to prod. It makes sense since today you cannot visualize the coverage as you do for Apex classes. Without coverage, it is easier to make mistakes every time we update the Flow. Code coverage can help detect regressions, which are defects introduced when changes are made to your code. By re-running your tests after making changes, you can verify that the existing functionality is not impacted. This makes it easier to identify and fix bugs, leading to more efficient troubleshooting and maintenance of your application. Overall, code coverage plays a crucial role in ensuring the quality and reliability of your software by providing insight into the effectiveness of your testing efforts and aiding in the identification of areas that require additional attention.

Despite these drawbacks, Salesforce Flows can still be a powerful tool for building declarative automation, especially for users who are not comfortable with coding. It’s important to evaluate your specific business requirements and consider these limitations before deciding to use Flows as part of your Salesforce implementation.

November 10, 2023How to publish Salesforce platform events from Salesforce API from Node.js
November 7, 2023How to generate Database.SaveResult mocks in Salesforce
October 19, 2023How to disable parallel tests in Salesforce
October 3, 2023SFDX CLI Error: default level:TRACE must be included in custom levels
September 23, 2023What is Dreamforce?
September 21, 2023Example of Apex HttpCalloutMock
How to publish Salesforce platform events from Salesforce API from Node.js

November 10th, 2023
Reading Time: < 1 minute
Salesforce platform events from Salesforce API using Node.js, follow these steps:

Install the jsforce package, which provides a Salesforce API client for Node.js. You can use npm to install it by running the following command in your project directory:
```
npm install jsforce 
```
Use the following code as a starting point to connect to the Salesforce API and publish a platform event:
```
const jsforce = require('jsforce');

// Salesforce credentials 
const username = '<YOUR_SALESFORCE_USERNAME>';
const password = '<YOUR_SALESFORCE_PASSWORD>';
const securityToken = '<YOUR_SALESFORCE_SECURITY_TOKEN>';

// Salesforce connection 
const conn = new jsforce.Connection();

conn.login(username, password + securityToken, (err, userInfo) => {
    if (err) { 
        return console.error(err); 
    }

    console.log('Connected to Salesforce');

    // Define the platform event name and payload   
    const eventApiName = 'My_Platform_Event__e';
    const eventPayload = { field1: 'value1', field2: 'value2' };

    // Publish the platform event   
    conn.sobject(eventApiName).create(eventPayload, (err, res) => {
        if (err) { return console.error(err); }
        console.log('Platform event published:', res);
    });
});
```
Make sure to replace <YOUR_SALESFORCE_USERNAME>, <YOUR_SALESFORCE_PASSWORD>, and <YOUR_SALESFORCE_SECURITY_TOKEN> with your Salesforce credentials. Also, modify the eventApiName and eventPayload variables to match your platform event’s API name and desired payload.

Run the Node.js script, and if everything is configured correctly, it should connect to Salesforce and publish the platform event.
```
node publish-platform-event.js
```
By following these steps, you should be able to publish Salesforce platform events from Salesforce API using Node.js.

November 15, 2023Salesforce Flows have this little big drawback
November 7, 2023How to generate Database.SaveResult mocks in Salesforce
October 19, 2023How to disable parallel tests in Salesforce
October 3, 2023SFDX CLI Error: default level:TRACE must be included in custom levels
September 23, 2023What is Dreamforce?
September 21, 2023Example of Apex HttpCalloutMock

Category: Development

Efficient and Cost-effective Content Delivery: Unlocking the Potential of GitHub Repositories with jsDelivr as a CDN

How to use a GitHub repository as a CDN with jsDelivr

How to purge a file from jsDelivr CDN

Minification support in jsDelivr

Documentation

httpbin.org: endpoints for testing

Salesforce Flows have this little big drawback

How to publish Salesforce platform events from Salesforce API from Node.js