Supercharge

https://superchargejs.com/docs/3.x/
Admin
Supercharge is a JavaScript utility library that provides a collection of helpful methods and...
Tokens:68,650
Snippets:440
Trust Score:6.7
Update:1 year ago
Show doc for...
Tokens:
Raw
### Install Supercharge.js

Source: https://superchargejs.com/docs/3.x/database

This snippet shows the command to install the Supercharge.js framework using npm. It's the first step to getting started with building applications using Supercharge.

```bash
npm install supercharge
```

--------------------------------

### Install Supercharge.js

Source: https://superchargejs.com/docs/3.x/responses

This snippet shows the command to install the Supercharge.js framework using npm, the Node Package Manager. It's the first step to getting started with building applications using Supercharge.

```bash
npm install supercharge
```

--------------------------------

### Install Supercharge.js

Source: https://superchargejs.com/docs/3.x/middleware

This snippet shows how to install the Supercharge.js framework using npm, the Node.js package manager.

```bash
npm install supercharge
```

--------------------------------

### Install @supercharge/set Package

Source: https://superchargejs.com/docs/3.x/set

Instructions on how to install the @supercharge/set package as a project dependency using npm.

```bash
npm i @supercharge/set
```

--------------------------------

### Install @supercharge/inertia Package

Source: https://superchargejs.com/docs/3.x/inertia

This command installs the @supercharge/inertia package, enabling Inertia.js integration within your Supercharge application.

```bash
npm i @supercharge/inertia
```

--------------------------------

### Install Promise Pool

Source: https://superchargejs.com/docs/3.x/promise-pool

Installs the @supercharge/promise-pool package as a project dependency using npm.

```bash
npm i @supercharge/promise-pool
```

--------------------------------

### Prepend prefix if string does not start with it

Source: https://superchargejs.com/docs/3.x/strings

The `start` method prepends a single instance of the given `prefix` to the start of the string if it doesn’t already start with the given prefix. Combining with `ltrim` can ensure a clean starting prefix.

```javascript
const start = Str('repos/supercharge')
    .start('/')
    .get()
// '/repos/supercharge'

const start = Str('/repos/supercharge')
    .start('/')
    .get()
// '/repos/supercharge'

const start = Str('///repos/supercharge')
    .start('/')
    .get()
// '///repos/supercharge'
```

```javascript
const start = Str('///repos/supercharge')
    .ltrim('/')
    .start('/')
    .get()

// '/repos/supercharge'
```

--------------------------------

### Supercharge Installation

Source: https://superchargejs.com/docs/3.x/about-supercharge

Instructions for installing the Supercharge Node.js framework. This typically involves using a package manager like npm or yarn.

```bash
npm install supercharge
# or
yarn add supercharge
```

--------------------------------

### Sttp HTTP Request Methods

Source: https://superchargejs.com/docs/3.x/sttp

Lists the available HTTP methods provided by the Sttp package for making requests: get, post, put, patch, delete, and options. Examples show basic usage with URL and optional parameters.

```javascript
const response = await Sttp.get(url, queryParams)
const response = await Sttp.post(url, payload)
const response = await Sttp.put(url, payload)
const response = await Sttp.patch(url, payload)
const response = await Sttp.delete(url, queryParams)
const response = await Sttp.options(url, queryParams)
```

--------------------------------

### Start Supercharge Web Application

Source: https://superchargejs.com/docs/3.x/application

Starts a Supercharge web application using the `server.ts` file. This is the primary method for serving HTTP requests with the framework.

```bash
ts-node server.ts
```

--------------------------------

### Install @supercharge/view Package

Source: https://superchargejs.com/docs/3.x/inertia

This command installs the @supercharge/view package, which is a requirement for the Inertia package and provides view rendering support for your Supercharge application.

```bash
npm i @supercharge/view
```

--------------------------------

### Install Supercharge Filesystem Package

Source: https://superchargejs.com/docs/3.x/filesystem

Installs the `@supercharge/filesystem` package as a project dependency using npm. This package can be used independently of the Supercharge framework.

```bash
npm i @supercharge/filesystem
```

--------------------------------

### Install @supercharge/macroable

Source: https://superchargejs.com/docs/3.x/macroable

Installs the @supercharge/macroable package as a project dependency using npm. This package can be used in any project, not just those built with Supercharge.

```bash
npm i @supercharge/macroable
```

--------------------------------

### Iterate Map Keys with keys()

Source: https://superchargejs.com/docs/3.x/map

Shows how to use the `keys()` method to get an iterator for all keys in the Map. It includes examples of retrieving keys individually and iterating using a `for..of` loop.

```javascript
const cache = new Map()

cache
  .set('user:1', 'Marcus')
  .set('user:2', 'Supercharge')

const keyIterator = cache.keys()

keyIterator.next().value
// 'user:1'

keyIterator.next().value
// 'user:2'
```

```javascript
const cache = new Map()

cache
  .set('user:1', 'Marcus')
  .set('user:2', 'Supercharge')

for (const key of cache.keys()) {
  console.log(`"${key}" mapping to --> ${cache.get(key)}`)
}

// "user:1" mapping to --> Marcus
// "user:2" mapping to --> Supercharge
```

--------------------------------

### Import Filesystem from Supercharge Framework

Source: https://superchargejs.com/docs/3.x/filesystem

Retrieves the filesystem package instance directly from the Supercharge framework if you are already using it. This avoids the need for a separate installation.

```javascript
const Fs = require('@supercharge/framework/filesystem')
```

--------------------------------

### Run the Supercharge Server

Source: https://superchargejs.com/docs/3.x/installation

Start the Supercharge HTTP server using the 'npm run dev' command. The server runs on the port defined in the .env file, defaulting to 3000.

```bash
npm run dev
```

--------------------------------

### Install @supercharge/map

Source: https://superchargejs.com/docs/3.x/map

Installs the @supercharge/map package using npm. This package can be used independently of the Supercharge framework.

```bash
npm i @supercharge/map
```

--------------------------------

### Install @supercharge/strings

Source: https://superchargejs.com/docs/3.x/strings

Installs the @supercharge/strings package as a project dependency using npm. This package can be used in any project, independent of the Supercharge framework.

```bash
npm i @supercharge/strings
```

--------------------------------

### Install @supercharge/arrays

Source: https://superchargejs.com/docs/3.x/arrays

Installs the @supercharge/arrays package as a project dependency using npm. This package can be used in any project, independent of the Supercharge framework.

```bash
npm i @supercharge/arrays
```

--------------------------------

### Install @supercharge/sttp

Source: https://superchargejs.com/docs/3.x/sttp

Installs the @supercharge/sttp package as a project dependency using npm. This package can be used independently of the Supercharge framework.

```bash
npm i @supercharge/sttp
```

--------------------------------

### Define a Basic GET Route

Source: https://superchargejs.com/docs/3.x/routing

Creates a simple GET route for '/hello' that returns a string. This demonstrates the fundamental usage of the Route facade to define a route and its handler.

```javascript
import { Route } from '@supercharge/facades'

Route.get('/hello', () => {
    return 'Hello you!'
})
```

--------------------------------

### Start Supercharge Console Application

Source: https://superchargejs.com/docs/3.x/application

Starts a Supercharge console application using the `craft.ts` file. This is used for running CLI commands and background tasks.

```bash
ts-node craft.ts
```

--------------------------------

### Boot Markdown Service Asynchronously

Source: https://superchargejs.com/docs/3.x/service-providers

Illustrates how to boot the MarkdownRenderer service after all providers have been registered. This method runs asynchronously and is suitable for tasks like loading files, as shown with the example of loading a syntax highlighting theme.

```typescript
import { ServiceProvider } from '@supercharge/support'
import { MarkdownRenderer } from './markdown-renderer'

export class MarkdownServiceProvider extends ServiceProvider {
  /**
   * Boot application services.
   */
  override async boot (): Promise<void> {
    await this.app().make(MarkdownRenderer).boot()
  }
}
```

--------------------------------

### Handlebars Base Layout Example

Source: https://superchargejs.com/docs/3.x/handlebars

An example of a Handlebars base layout file for a SuperchargeJS application. This layout defines the overall HTML structure, including head, body, partials for hero and footer, and a content placeholder.

```html
<!DOCTYPE html>
<html>

<head>
    <link rel="stylesheet" href="/css/style.css">
</head>

<body>

    {{> hero }}

    <div class="container" role="main">
        <div class="row">
            {{{ content }}}
        </div>
    </div>

    {{> footer }}

</body>

</html>
```

--------------------------------

### Install @supercharge/goodies Package

Source: https://superchargejs.com/docs/3.x/goodies

Installs the @supercharge/goodies package as a project dependency using npm. This package can be used independently of the Supercharge framework.

```bash
npm i @supercharge/goodies
```

--------------------------------

### Install @supercharge/collections Package

Source: https://superchargejs.com/docs/3.x/collections

Provides the npm command to install the @supercharge/collections package as a project dependency. This package can be used independently of the Supercharge framework.

```bash
npm i @supercharge/collections
```

--------------------------------

### Install @supercharge/streams

Source: https://superchargejs.com/docs/3.x/streams

Installs the @supercharge/streams package as a project dependency using npm. This package can be used in any Node.js project, independent of the Supercharge framework.

```bash
npm i @supercharge/streams
```

--------------------------------

### Define a Basic GET Route for User

Source: https://superchargejs.com/docs/3.x/routing

Illustrates defining a GET route for '/user' that returns a greeting. This is a common pattern for handling user-specific requests in web applications.

```javascript
import { Route } from '@supercharge/facades'

Route.get('/user', () => {
    return 'Hello Supercharge'
})
```

--------------------------------

### Supercharge Logger Methods by Severity Level

Source: https://superchargejs.com/docs/3.x/logger

Provides examples of using the various logger methods available in Supercharge, corresponding to standard syslog log levels.

```javascript
import { Logger } from '@supercharge/facades'

Logger.emergency(message);
Logger.alert(message);
Logger.critical(message);
Logger.error(message);
Logger.warning(message);
Logger.notice(message);
Logger.info(message);
Logger.debug(message);
```

--------------------------------

### Create a Basic View Template

Source: https://superchargejs.com/docs/3.x/views

Example of a simple Handlebars view template that displays a greeting with a dynamic name. Views are typically stored in the `resources/views` directory.

```html
<div>
  <h1>Hej, great to see you {{name}}</h1>
</div>
```

--------------------------------

### Send a Basic GET Request with Sttp

Source: https://superchargejs.com/docs/3.x/sttp

Shows how to send a simple GET request to a specified URL using the Sttp.get method. The response from the HTTP request is captured in the 'response' variable.

```javascript
import { Sttp } from '@supercharge/sttp'

const response = await Sttp.get('https://your-api.com/v2/users')
```

--------------------------------

### Send Query Parameters with GET Request

Source: https://superchargejs.com/docs/3.x/sttp

Demonstrates sending query parameters to a GET request either by appending a query string or using the `withQueryParams` method. It also shows an alternative of passing parameters as the second argument to `Sttp.get`.

```javascript
const response = await Sttp
  .withQueryParams({
    name: 'Supercharge',
    page: 1
  })
  .get('https://your-api.com/v2/users')
```

```javascript
const response = await Sttp.get('https://your-api.com/v2/users', {
    name: 'Supercharge',
    page: 1
  })
```

--------------------------------

### Registering Service Providers in bootstrap/providers.ts

Source: https://superchargejs.com/docs/3.x/service-providers

Provides an example of how to register service providers by exporting an array of provider constructors from the `bootstrap/providers.ts` file. This includes adding custom or community package providers to the application's bootstrap process.

```typescript
import { MarkdownServiceProvider } from '../app/modules/markdown'

export const providers: ServiceProviderCtor[] = [
  // other service providers

  MarkdownServiceProvider,
]
```

--------------------------------

### Check Node.js Version

Source: https://superchargejs.com/docs/3.x/installation

This command checks the installed Node.js version on your system. Supercharge requires Node.js v16 or higher.

```bash
node -v
# v16.15.1
```

--------------------------------

### Create and Process Promise Pool

Source: https://superchargejs.com/docs/3.x/promise-pool

An example of creating a PromisePool instance for a list of numbers and processing them, returning results and errors.

```javascript
import { PromisePool } from '@supercharge/promise-pool'

const { results, errors } = await PromisePool
  .for([1, 2, 3])
  .process(async num => {
    return num * 2
  })
// results: [2, 4, 6]
// errors: []
```

--------------------------------

### Basic String Manipulation with @supercharge/strings (CommonJS)

Source: https://superchargejs.com/docs/3.x/strings

Demonstrates how to use the @supercharge/strings package to perform string manipulations like trimming, title-casing, and retrieving the final string value. This example uses CommonJS module syntax.

```javascript
const Str = require('@supercharge/strings')

const title = Str('  Supercharge is sweet! ')
    .trim()
    .title()
    .get()

// 'Supercharge Is Sweet!'
```

--------------------------------

### Available Router Methods

Source: https://superchargejs.com/docs/3.x/routing

Lists the supported HTTP verbs for defining routes in Supercharge JS. This includes GET, POST, PUT, DELETE, PATCH, and OPTIONS, along with their basic syntax.

```javascript
Route.get(uri, routeHandler)
Route.post(uri, routeHandler)
Route.put(uri, routeHandler)
Route.delete(uri, routeHandler)
Route.patch(uri, routeHandler)
Route.options(uri, routeHandler)
```

--------------------------------

### Get All Collection Items

Source: https://superchargejs.com/docs/3.x/collections

The 'all' method returns the collection's underlying array. Starting from version 2.0, you can also await a collection to resolve and return the array.

```JavaScript
await Collect([1, 2, 3]).all()

// [1, 2, 3]
```

```JavaScript
await Collect([1, 2, 3])

// [1, 2, 3]
```

--------------------------------

### Scaffold a New Supercharge App

Source: https://superchargejs.com/docs/3.x/installation

Use the npm init command to scaffold a new Supercharge application. This command creates a new app in the specified directory.

```bash
npm init @supercharge/app@latest hello-supercharge
```

--------------------------------

### Add Macro to a Class using Macroable

Source: https://superchargejs.com/docs/3.x/macroable

Shows how to add a 'macro' (a function) to a class by extending the Macroable base class and using the static `Class.macro` method. This example adds a 'hello' method to the User class.

```javascript
import { Macroable } from '@supercharge/macroable'

class User extends Macroable {
  private firstname: string = 'Supercharge'
}

// in another file/package
User.macro('hello', function () {
  return `Hello ${this.firstname}!`
})

const user = new User()

user.hello()
// Hello Supercharge!
```

--------------------------------

### Pipe Stream Into Output Stream

Source: https://superchargejs.com/docs/3.x/streams

Starts the streaming pipeline and pipes the results into a specified output stream. This method returns a promise that resolves when the pipeline is complete. The example demonstrates piping to a file write stream.

```JavaScript
await Stream([1, 2, 3])
  .inObjectMode()
  .into(
    Fs.createWriteStream('./example-output-file.csv')
  )
```

--------------------------------

### Get Substring from String

Source: https://superchargejs.com/docs/3.x/strings

The substr method extracts a portion of a string based on a starting index and an optional ending index. If no ending index is provided, it extracts to the end of the string. If called without arguments, it returns the entire string.

```javascript
const substr = Str('Supercharge')
    .substr(0, 5)
    .get()
// 'Super'

const substr = Str('Supercharge')
    .substr(5, 0)
    .get()
// 'Super'

const substr = Str('Supercharge')
    .substr(5)
    .get()
// 'charge'

const substr = Str('Supercharge')
    .substr()
    .get()
// 'Supercharge'
```

--------------------------------

### Determine if string starts with a substring

Source: https://superchargejs.com/docs/3.x/strings

The `startsWith` method determines whether the string starts with the given `needle`. An optional `position` argument can specify the starting index for the search.

```javascript
const startsWith = Str('Supercharge').startsWith('charge')
// false
```

```javascript
const startsWith = Str('Supercharge').startsWith('charge', 5)
// true
```

--------------------------------

### Iterate Map Entries with entries()

Source: https://superchargejs.com/docs/3.x/map

Demonstrates how to use the `entries()` method to get an iterator for `[key, value]` pairs in a Map. It shows how to retrieve individual entries using `iterator.next().value` and how to iterate using a `for..of` loop.

```javascript
const cache = new Map()

cache
  .set('user:1', 'Marcus')
  .set('user:2', 'Supercharge')

const iterator = cache.entries()

iterator.next().value
// ['user:1', 'Marcus']

iterator.next().value
// ['user:2', 'Supercharge']
```

```javascript
const cache = new Map()

cache
  .set('user:1', 'Marcus')
  .set('user:2', 'Supercharge')

for (const [key, value] of cache.entries()) {
  console.log(`"${key}" mapping to --> ${value}`)
}

// "user:1" mapping to --> Marcus
// "user:2" mapping to --> Supercharge
```

--------------------------------

### Inspect SttpResponse Attributes

Source: https://superchargejs.com/docs/3.x/sttp

Provides examples of interacting with the `SttpResponse` instance returned by outgoing requests. It shows how to access status, payload, headers, and check the response status (success, redirect, error).

```javascript
const response = await Sttp
  .withPayload({ name: 'Supercharge' })
  .post('/api/users')

response.status(): number
// 201

response.payload(): any
// { id: 1, name: 'Supercharge' }

response.headers(): object
// { 'content-type': 'application/json' }

response.isSuccess(): boolean
// true

response.isRedirect(): boolean
// false

response.isError(): boolean
// false

response.isClientError(): boolean
// false

response.isServerError(): boolean
// false
```

--------------------------------

### Create and Register a Service Provider in Supercharge

Source: https://superchargejs.com/docs/3.x/service-providers

Demonstrates how to create a custom service provider by extending the `ServiceProvider` class from `@supercharge/support`. It shows the implementation of the `register` method to bind a service to the container and the `boot` method to execute asynchronous bootstrapping logic.

```typescript
import { ServiceProvider } from '@supercharge/support'
import { MarkdownRenderer } from './markdown-renderer'

export class MarkdownServiceProvider extends ServiceProvider {
  /**
   * Register application services into the container.
   */
  override register (): void {
    this.app().singleton(MarkdownRenderer, () => {
      return new MarkdownRenderer(this.app())
    })
  }

  /**
   * Boot application services.
   */
  override async boot (): Promise<void> {
    await this.app().make(MarkdownRenderer).boot()
  }
}
```

--------------------------------

### Async Array Operations with Supercharge Collections

Source: https://superchargejs.com/docs/3.x/collections

Demonstrates fetching users by ID and filtering them based on subscription status using the async map and filter methods of @supercharge/collections. The example then iterates through the filtered users to subscribe them.

```javascript
import { Collect } from '@supercharge/collections'

await Collect([ 1, 2, 3, 4, 5 ])
  .map(async id => {
    return await User.findById(id)
  })
  .filter(async user => {
    return await user.notSubscribedToNewsletter()
  })
  .forEach(user => {
    await user.subscribe()
  })
```

--------------------------------

### Create and Configure Sttp Instance

Source: https://superchargejs.com/docs/3.x/sttp

Demonstrates creating a reusable Sttp instance using `Sttp.create()` and assigning default values like base URL, headers, and timeouts using fluent methods.

```javascript
const instance = Sttp.create()
```

```javascript
const instance = Sttp.create()
  .withBaseUrl('https://your-api.com/v2/')
  .withHeaders({
    'X-Custom-Header': 'value'
  })
  .withTimeoutInSeconds(2)
```

--------------------------------

### Working with Supercharge Sets

Source: https://superchargejs.com/docs/3.x/set

Demonstrates how to import and use the Supercharge Set class, including adding elements, checking emptiness, mapping values, and finding elements. It highlights the differences from the native JavaScript Set.

```JavaScript
const Set = require('@supercharge/set')

const users = Set.from([])

users.isEmpty()
// true

users
  .add({ id: 1, name: 'Marcus' })
  .add({ id: 2, name: 'Norman' })
  .add({ id: 3, name: 'Christian' })

users.isNotEmpty()
// true

const usernamesArray = users
  .map(user => {
    return user.name
  })
  .toArray()

// [ 'Marcus', 'Norman', 'Christian' ]

const marcus = users.find(user => {
  return user.name === 'Marcus'
})

// { id: 1, name: 'Marcus' }
```

--------------------------------

### Define Route with Path Parameter

Source: https://superchargejs.com/docs/3.x/routing

Demonstrates how to define a route that captures dynamic segments from the URI using path parameters. The example shows capturing a 'name' parameter and using it within the route handler.

```javascript
Route.get('/hello/:name', ({ request }) => {
    const name = request.param('name')

    return `Hello ${name}`
})
```

--------------------------------

### Check Dependencies for Security

Source: https://superchargejs.com/docs/3.x/deployment

Use the 'npm audit' command to scan your project's dependencies for known security vulnerabilities and receive recommendations for remediation.

```bash
npm audit
```

--------------------------------

### Serve a View from a Subdirectory

Source: https://superchargejs.com/docs/3.x/views

Illustrates how to serve a view located in a subdirectory (e.g., `resources/views/auth/login.hbs`) by using a path-like structure in the `h.view()` method.

```javascript
{
  method: 'GET',
  path: '/welcome',
  handler: (request, h) => {
    return h.view('auth/login')
  }
}
```

--------------------------------

### Create a Collection Instance with Supercharge

Source: https://superchargejs.com/docs/3.x/collections

Demonstrates the basic usage of creating a new collection instance by importing the 'Collect' function from '@supercharge/collections' and passing an array to it.

```javascript
const { Collect } = require('@supercharge/collections')

const collection = Collect([ 'Supercharge', 'Collection' ])
```

--------------------------------

### Supercharge Configuration and Environment Variables

Source: https://superchargejs.com/docs/3.x/about-supercharge

Details on how to configure a Supercharge application, including the use of environment variables for managing settings across different environments.

```javascript
// app/config/app.js
module.exports = {
  name: process.env.APP_NAME || 'Supercharge',
  environment: process.env.NODE_ENV || 'development',
};

// .env file example
APP_NAME=MyAwesomeApp
NODE_ENV=production
```

--------------------------------

### Serve a View from a Route Handler

Source: https://superchargejs.com/docs/3.x/views

Demonstrates how to serve a view named 'welcome' with a 'name' property from a route handler using `h.view()`. This method takes the view name and a data object as arguments.

```javascript
{
  method: 'GET',
  path: '/welcome',
  handler: (request, h) => {
    return h.view('welcome', { name: 'Marcus' })
  }
}
```

--------------------------------

### Import Supercharge Filesystem Package

Source: https://superchargejs.com/docs/3.x/filesystem

Imports the Supercharge filesystem package into your Node.js application. This makes the filesystem utilities available for use.

```javascript
const Fs = require('@supercharge/filesystem')
```

--------------------------------

### Retrieve Value by Key with get()

Source: https://superchargejs.com/docs/3.x/map

Shows how the `get()` method retrieves the value associated with a given key. If the key is not found, it returns `undefined`.

```javascript
const cache = new Map()

cache
  .set('user:1', 'Marcus')
  .set('user:2', 'Supercharge')

cache.get('user:1')
// 'Marcus'

cache.get('user:5000')
// undefined
```

--------------------------------

### Extract section of string

Source: https://superchargejs.com/docs/3.x/strings

The `slice(start, end)` method returns a section of the string from `start` to `end`. This SuperchargeJS method is useful for extracting substrings.

```javascript
const sliced = Str('Supercharge')
    .slice(1, 3)
    .get()

// 'up'
```

--------------------------------

### Determine if string starts with a byte-order-mark

Source: https://superchargejs.com/docs/3.x/strings

The `startsWithBom` method determines whether the given string starts with a byte-order-mark (BOM). This SuperchargeJS method is useful for character encoding checks.

```javascript
const startsWithBom = Str('Supercharge').startsWithBom()
// false
```

--------------------------------

### Supercharge Handlebars Integration

Source: https://superchargejs.com/docs/3.x/about-supercharge

Setting up and using Handlebars for server-side rendering of views within a Supercharge application.

```javascript
// app/views/welcome.hbs
<h1>Hello, {{ name }}!</h1>

// app/controllers/PageController.js
async showWelcome({ view, response }) {
  response.send(view.render('welcome', { name: 'Supercharge User' }));
}
```

--------------------------------

### Supercharge Application Structure

Source: https://superchargejs.com/docs/3.x/about-supercharge

An overview of the default directory structure for a Supercharge Node.js application, aiding in project organization and understanding.

```bash
app/
  config/
  controllers/
  middleware/
  models/
  providers/
  routes/
bootstrap/
  http.js
  console.js
.env
.env.example
package.json
tsconfig.json
```

--------------------------------

### Supercharge TypeScript Usage

Source: https://superchargejs.com/docs/3.x/about-supercharge

Demonstrates the use of TypeScript with the Supercharge framework, highlighting the benefits of static typing and IntelliSense.

```typescript
import express, { Request, Response } from 'express';
import { Container } from '@supercharge/container';

interface User {
  id: number;
  name: string;
}

const app = express();

app.get('/users/:id', async (req: Request, res: Response) => {
  const userId: number = parseInt(req.params.id, 10);
  // Assume fetching user from a service or database
  const user: User = { id: userId, name: 'Example User' };

  res.json(user);
});

console.log('Supercharge app running with TypeScript!');
```

--------------------------------

### Get String Characters with SuperchargeJS

Source: https://superchargejs.com/docs/3.x/strings

The `chars` method returns an array containing each character of the string.

```JavaScript
const chars = Str('Super').chars()
// ['S', 'u', 'p', 'e', 'r']

const chars = Str('Super 👍').chars()
// ['S', 'u', 'p', 'e', 'r', ' ', '👍']
```

--------------------------------

### Check for Byte-Order Mark (BOM) with SuperchargeJS

Source: https://superchargejs.com/docs/3.x/strings

The `containsBom` method determines if the string starts with a byte-order mark (BOM).

```JavaScript
const containsBom = Str('Supercharge').containsBom()
// false
```

--------------------------------

### Hash Passwords with Supercharge

Source: https://superchargejs.com/docs/3.x/hashing

Demonstrates how to create a hash of a given string value using the 'make' method from the Hash facade in Supercharge.

```javascript
import { Hash } from '@supercharge/facades'

const hashedValue = Hash.make('plain-text')
```

--------------------------------

### Work with Supercharge Arrays

Source: https://superchargejs.com/docs/3.x/arrays

Provides examples of using the @supercharge/arrays package to manipulate array data. It showcases creating an array, checking if it's empty, adding elements, checking its length, mapping values, and finding elements within the array.

```javascript
const { Arr } = require('@supercharge/arrays')

const users = Arr.from([])

users.isEmpty()
// true

users
  .push({ id: 1, name: 'Marcus' })
  .push({ id: 2, name: 'Norman' })
  .push({ id: 3, name: 'Christian' })

users.isNotEmpty()
// true

users.length()
// 3

const usernamesArray = users
  .map(user => user.name)
  .toArray()
// [ 'Marcus', 'Norman', 'Christian' ]

const marcus = users.find(user => {
  return user.name === 'Marcus'
})
// { id: 1, name: 'Marcus' }
```

--------------------------------

### Get stream instance with .asStream()

Source: https://superchargejs.com/docs/3.x/streams

Demonstrates retrieving the stream instance from a Supercharge Stream object using the .asStream() method.

```javascript
const stream = Stream([1, 2, 3]).asStream()
```

--------------------------------

### Add Elements to the Beginning of a Collection (JavaScript)

Source: https://superchargejs.com/docs/3.x/collections

The `unshift` method adds one or more elements to the start of a collection and returns the modified collection.

```javascript
await Collect([1, 2, 3]).unshift(5, 6)

// [5, 6, 1, 2, 3]
```

--------------------------------

### Supercharge.js Craft Console Overview

Source: https://superchargejs.com/docs/3.x/craft-console

This section provides an overview of the Craft Console in Supercharge.js, a tool for managing application tasks and commands. Further details are to be announced (Tba.).

```javascript
/*
  Craft Console Overview
  Tba.
*/
```

--------------------------------

### Get Collection Size (size)

Source: https://superchargejs.com/docs/3.x/collections

The `size` method returns the number of items currently in the collection. This method was added in version 1.1.

```javascript
await Collect([1, 2, 3]).size()

// 3
```

--------------------------------

### Get Map Size with size - JavaScript

Source: https://superchargejs.com/docs/3.x/map

The `size` property returns the number of key-value pairs currently stored in the map.

```javascript
const map = new Map([
  ['key', 'value'] // adding the first pair
])

map.set('name', 'Marcus') // adding the second pair

const size = map.size
// 2
```

--------------------------------

### Inertia Partial Views in HTML

Source: https://superchargejs.com/docs/3.x/inertia

A sample view file containing the Inertia-related `inertia` and `inertiaHead` partial views, which render HTML injected into the head and body elements.

```html
<!DOCTYPE html>
<html lang="en">
  <head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Supercharge Inertia</title>

    {{> inertiaHead }}
  </head>
  <body>
    {{> inertia }}
  </body>
</html>
```

--------------------------------

### Get Value or Default with getOrDefault()

Source: https://superchargejs.com/docs/3.x/map

Illustrates the `getOrDefault()` method, which returns the value for a key or a specified `defaultValue` if the key is absent.

```javascript
const cache = new Map()

cache
  .set('user:1', 'Marcus')
  .set('user:2', 'Supercharge')

cache.getOrDefault('user:1', 'Default-Username')
// 'Marcus'

cache.getOrDefault('user:5000', 'Default-Username')
// 'Default-Username'
```

--------------------------------

### Configure Inertia View Template

Source: https://superchargejs.com/docs/3.x/inertia

Configures the view template used by the Inertia package to render the initial view. This setting requires a file located within the `resources/views` directory.

```typescript
const inertiaConfig: InertiaOptions = {
  /**
   * This setting requires a file located inside the `resources/views` directory.
   * When changing the value for the `view` configuration, you need to make
   * sure a file exists in the views directory. For example, the current
   * configuration requires a view file at `resources/views/inertia.hbs`.
   */
  view: 'inertia'
}
```

--------------------------------

### Get the number of items in an array

Source: https://superchargejs.com/docs/3.x/arrays

The `length` method returns the total count of elements within the array. This method is available from version 1.0.

```javascript
Arr
  .from([1, 2, 3])
  .length()

// 3
```

--------------------------------

### Trim Whitespace from String Start

Source: https://superchargejs.com/docs/3.x/strings

The `ltrim` method removes whitespace from the beginning of a string. It can also be used to trim specific characters from the front.

```JavaScript
const trimmed = Str('   Supercharge is nice  ')
    .ltrim()
    .get()

// 'Supercharge is nice  '
```

```JavaScript
const trimmed = Str('///supercharge/')
    .ltrim('/')
    .get()

// 'supercharge/'
```

--------------------------------

### Get the size (length) of an array

Source: https://superchargejs.com/docs/3.x/arrays

The `size` method is an alias for the `length` method, returning the number of elements in the array. This method is available from version 1.0.

```javascript
const names = Arr.from(['Marcus', 'Supercharge'])

const size = names.size()
// 2
```

--------------------------------

### Create Set with Initial Values (Deprecated)

Source: https://superchargejs.com/docs/3.x/set

Demonstrates the deprecated static `Set.of` method for creating a new set instance with provided values. It's recommended to use `Set.from` instead.

```JavaScript
const set = Set.of(['Marcus', 'Supercharge'])

set.has('Marcus')
// true
```

--------------------------------

### Get Supercharge Application Base Path

Source: https://superchargejs.com/docs/3.x/application

Retrieves the absolute path to the root directory of your Supercharge application. This is fundamental for resolving other application paths.

```typescript
const path = app.basePath()
// /home/users/marcus/dev/supercharge/superchargejs.com
```

--------------------------------

### Create Symbolic Link with Fs.ensureSymlink

Source: https://superchargejs.com/docs/3.x/filesystem

Creates a symbolic link from one file to another using Fs.ensureSymlink. This function requires the 'from' and 'to' paths. Note that symlink creation might require administrator privileges on Windows.

```JavaScript
await Fs.ensureSymlink('archive/tutorial-1.md', 'posts/tutorial-1.md')
```

--------------------------------

### Get String Length (length)

Source: https://superchargejs.com/docs/3.x/strings

The `length` method returns the number of characters in a string. This is a fundamental string operation for various text processing tasks.

```javascript
const length = Str('Supercharge').length()
// 11
```

--------------------------------

### Get Unique Objects by Key with uniqueBy

Source: https://superchargejs.com/docs/3.x/arrays

The uniqueBy method returns unique values from an array of objects based on a callback function that specifies the key for uniqueness.

```JavaScript
Arr.from([
  { name: 'Marcus' },
  { name: 'Marcus' },
  { name: 'Supercharge' }
])
  .uniqueBy(user => {
    return user.name
  })

/*
[
  { name: 'Marcus' },
  { name: 'Supercharge' }
]
*/
```

--------------------------------

### PM2 Configuration for Zero-Downtime Deployments

Source: https://superchargejs.com/docs/3.x/deployment

This JSON configuration file is used with PM2 to manage Node.js applications in a production environment. It enables cluster mode for high availability and configures settings for graceful restarts, ensuring zero-downtime deployments. The `wait_ready` and `listen_timeout` options are crucial for signaling when an application instance is ready to receive traffic.

```JSON
{
  "apps": [
    {
      "name": "superchargejs.com",
      "script": "./node_modules/ts-node/dist/bin.js",
      "args": "server.ts",
      "exec_mode": "cluster",
      "instances": 2,

      "wait_ready": true,
      "listen_timeout": 15000,

      "env": {
        "NODE_ENV": "production",
        "PORT": 2021
      }
    }
  ]
}
```

--------------------------------

### Get Unique Values with unique

Source: https://superchargejs.com/docs/3.x/arrays

The unique method returns all unique values present in the array. For complex data structures like objects, use uniqueBy.

```JavaScript
Arr.from([1, 2, 2, 3, 4, 4, 4, 5]).unique()

// [1, 2, 3, 4, 5]
```

--------------------------------

### Register Markdown Service with Factory Callback

Source: https://superchargejs.com/docs/3.x/service-providers

Demonstrates how to register the MarkdownRenderer service into the container using a factory callback. This method runs synchronously and binds a resolved, not-booted instance of the service.

```typescript
import { ServiceProvider } from '@supercharge/support'
import { MarkdownRenderer } from './markdown-renderer'

export class MarkdownServiceProvider extends ServiceProvider {
  /**
   * Register application services into the container.
   */
  override register (): void {
    this.app().singleton(MarkdownRenderer, () => {
      return new MarkdownRenderer(
        this.app().config().get('markdown')
      )
    })
  }
}
```

--------------------------------

### Transform String to StudlyCase

Source: https://superchargejs.com/docs/3.x/strings

The studly method converts a string to StudlyCase, where each word starts with an uppercase letter and there are no spaces. This is similar to camelCase but with the first letter capitalized.

```javascript
const studly = Str('Supercharge is SWEET')
    .studly()
    .get()
// 'SuperchargeIsSweet'
```

--------------------------------

### Get File Extension with Fs.extension

Source: https://superchargejs.com/docs/3.x/filesystem

Retrieves the extension of a file using Fs.extension. This function returns the file extension, including the leading dot. It requires the file path.

```JavaScript
const extension = await Fs.extension('blog.md'))
// '.md'
```

--------------------------------

### Run Application with Process Manager

Source: https://superchargejs.com/docs/3.x/deployment

Utilize a process manager like PM2 to keep your Node.js application running continuously, handle restarts, and manage application clustering for better performance and reliability.

```bash
pm2 start app.js --name my-supercharge-app
```

--------------------------------

### Create Temporary Directory with Fs.tempDir

Source: https://superchargejs.com/docs/3.x/filesystem

Creates a temporary directory using Fs.tempDir. The operating system automatically cleans up these directories. It requires a path prefix and creates the directory in a system-managed location.

```JavaScript
await Fs.tempDir('storage/avatars')
```

--------------------------------

### size: Get the Number of Entries in a Set

Source: https://superchargejs.com/docs/3.x/set

The size method returns the total number of entries currently present in the set. This is a fundamental property for understanding the cardinality of the set.

```javascript
const set = Set.from(['Marcus', 'Supercharge'])

const size = set.size()
// 2
```

--------------------------------

### Asset Versioning using Manifest File Hash

Source: https://superchargejs.com/docs/3.x/inertia

Configures asset versioning by resolving the asset version using an async callback that calculates the MD5 hash of the manifest file content.

```javascript
import { Inertia } from '@supercharge/inertia'

const inertiaConfig: InertiaOptions = {
  …

  version: async (app: Application) => {
    return await Inertia.manifestFile(
      app.publicPath('js/manifest.json')
    )
  }
}
```

--------------------------------

### Get Directory Name with Fs.dirname

Source: https://superchargejs.com/docs/3.x/filesystem

Returns the directory name of a given path using Fs.dirname. This method extracts the directory portion from a file path. It takes the path as an argument.

```JavaScript
const date = await Fs.dirname('/storage/app/blog.md'))
// /storage/app
```

--------------------------------

### Asset Versioning using Application Version

Source: https://superchargejs.com/docs/3.x/inertia

Configures asset versioning by using the application version, which is suitable when following a semantic release process that bumps the application version with each release.

```javascript
import { Inertia } from '@supercharge/inertia'

const inertiaConfig: InertiaOptions = {
  …

  version: (app: Application) => {
    return app.version()
  }
}
```

--------------------------------

### Get File Stats with Fs.stat

Source: https://superchargejs.com/docs/3.x/filesystem

Retrieves file statistics using Fs.stat. This method returns a Stats instance containing properties about the file. It requires the file path as input.

```JavaScript
const stats = await Fs.stat('avatar.png'))
```

--------------------------------

### Get App Database Path

Source: https://superchargejs.com/docs/3.x/application

Returns the absolute path to the application's database directory. Can also generate a path to a specific file within the database directory.

```JavaScript
const path = app.databasePath()
// <base-path>/database

const path = app.databasePath('migrations/create-users-table-20220124.ts')
// <base-path>/database/migrations/create-users-table-20220124.ts
```

--------------------------------

### Get App Storage Path

Source: https://superchargejs.com/docs/3.x/application

Returns the absolute path to the application's storage directory. Can also generate a path to a specific file within the storage directory.

```JavaScript
const path = app.storagePath()
// <base-path>/storage

const path = app.storagePath('cache/sessions')
// <base-path>/storage/cache/sessions
```

--------------------------------

### Create Temporary File with Fs.tempFile

Source: https://superchargejs.com/docs/3.x/filesystem

Creates a temporary file handle using Fs.tempFile. The operating system automatically cleans up these files. It takes a file name prefix and returns the path to the temporary file.

```JavaScript
const tempAvatar = await Fs.tempFile('user-1-avatar-upload')
await Fs.writeFile(tempAvatar, content)
```
Tokens:
Raw