Node's Pretty Magical

    figit
    TypeScript icon, indicating that this package has built-in type declarations

    0.0.8 • Public • Published

    figit

    JavaScript and Handlebars data templates - Producing templated configuration has never been easier!

    Or expand JSON and YAML templates using Handlebars template syntax.

    I use this to produce Kubernetes configurations from templates.

    If you like this project, please star this repo and support my work

    Features

    • Produce data from JavaScript code.
    • Produce data from templated YAML and JSON files.
    • Use variables, environment variables and whatever data sources you like.
    • Use whatever npm packages you like.
    • Use YAML and JSON data files and standard input for Handlebars template data.

    Install it

    npm install -g figit

    Command line reference

    Evaluate file.js and output JSON:

    figit file.js
    

    Evaluate multiple files and output YAML:

    figit file1 file2 fileN --output yaml
    

    General use:

    figit [file+] --output json | yaml [--stdin json | yaml] [--data <json-or-yaml-data-file>]
    

    A simple JavaScript template

    Create a template:

    // myfile.js
    module.exports = {
        /* Whatever code you want here to produce data. */
        data: {
            msg: "Hello world!",
        },
    };

    Instantiate data from the template:

    figit myfile.js

    JSON output:

    {
        "data": {
            "msg": "Hello world!"
        }
    }

    Or output YAML:

    figit myfile.js --output yaml

    YAML output:

    data:
        msg: "Hello world!"

    A simple data template

    Create a JSON template:

    // myfile.json
    {
        "data": {
            "msg": "{{MESSAGE}}",
        },
    };

    Or create a YAML template instead:

    # myfile.yaml
    data:
        msg: "{{MESSAGE}}"

    Create a file to contain the Handlebars template data (this can be JSON or YAML as well):

    // mydata.json
    {
        "MESSAGE": "Hello world!"
    }

    Note: Template variables are also populated from environment variables, so you don't necessarily need to create a template data, you could instead set a MESSAGE environment variable like this:

    export MESSAGE="Hello world"

    Instantiate data from the template and output as JSON:

    figit myfile.json --data mydata.json --output json

    JSON output:

    {
        "data": {
            "msg": "Hello world!"
        }
    }

    Or output YAML:

    figit myfile.json --data mydata.json --output yaml

    YAML output:

    data:
        msg: "Hello world!"

    You can also combine template data from a data file, environment variables and standard input.

    Load template data from a file like this:

    figit myfile.json --data mydata.json

    Template data is overwritten by environment variables, so in this case a MESSAGE environment variable would override the MESSAGE field from the data file.

    You can read template from standard input in JSON or YAML format like this:

    figit myfile.json --stdin json < mydata.json

    You can use this to pipe sensitive variables from one process to another without having to save them to disk.

    You can combine the methods of loading template data:

    figit myfile.json --data base-data.json --stdin json < override-data.json

    This allows you to have multiple levels of data. Base template data is read from the file specified by --data. Environment variables can then override the base data. Finally data read from standard input provides the final values for template data.

    A complex JavaScript template

    Here's my usecase for Figit, templating Kubernetes configurations.

    // mydeployment.js
    const APP_NAME = process.env.APP_NAME;
    if (!APP_NAME) {
        throw new Error(`Expected environment variable ${APP_NAME}`);
    }
    
    module.exports = {
        apiVersion: "apps/v1",
        kind: "Deployment",
        metadata: {
            name: ,
            labels: {
                app: APP_NAME,
            },
        },
        spec: {
            replicas: 3,
            selector: {
                matchLabels: {
                    app: APP_NAME,
                },
            },
            template: {
                metadata: {
                    labels: {
                        app: APP_NAME,
                    },
                },
                spec: {
                    containers: [
                        {
                            name: APP_NAME,
                            image: IMAGE_NAME,
                            ports: [
                                {
                                    containerPort: 80,
                                },
                            ],
                        },
                    ],
                },
            },
        },
    };

    Then in my deployment pipeline:

    export APP_NAME=myapp
    export IMAGE_NAME=myimage:latest
    figit mydeployment.js | kubectl apply -f -

    Keywords

    none

    Install

    npm i figit

    DownloadsWeekly Downloads

    17

    Version

    0.0.8

    License

    MIT

    Unpacked Size

    88.6 kB

    Total Files

    16

    Last publish

    Collaborators

    • ashleydavis