I have searched just about the entire internet for this so I am coming to you with a tough one. How do you spawn a node shell with a custom module pre loaded into it.

Alright, well this has had me going crazy but here is the bit hitch. I am working on a cli tool but would like to piggy back off of nodes shell to use their javascript parser. I would like to have something that starts a node shell with my npm package pre loaded and can be initialized with a file like lets say

$> myModule <fileName>
>

Once that is there I want to be able to run normal inputs like

> let a = 3;
> console.log(a);
3

But also be able to use custom funcitons from my module as well without having to require it into node.

> let a = myCustomeModule.class.function(input)
> console.log(a)
{ 
    some: 'json',
        object: {}
}

This is why it needs to pre load it. The issue is I can't seem to find any examples of anyone doing this.

Am I just going about this the wrong way, the main thing is to avoid having to write an entire node cli for this package.

Hello there!

I'm not sure I got the question right, but I think I understood the main parts, and hopefully what follows should help you getting started. The main part is the REPL API from NodeJs.

In the sample below, I'll create 2 dumb modules in which I define custom functions, then I write some repl bootstrap to customize the way the interactive NodejS (its repl) is launched, and we'll see my modules are loaded automatically:

Let's start with the modules we want to load:

moduleA.js

'use strict';
exports.echo = (a) => console.log(`echo from A ${a}`);

moduleB.js

'use strict';
exports.add = (a, b) => a + b;

Then the magic happens here, in the bootstrap repl:

repl.js

const repl = require('repl').start({useGlobal: true});
for (let myModule of ['moduleA', 'moduleB']) {
    repl.context[myModule] = require(`./${myModule}`);
}

(To keep things simple all these files are in the same folder, but you're free to complexify this at will)

Now, rather than just typing $ node to enter the repl console, use that bootstrap script: $ node repl.js And now you're in the interactive shell, as usual, but moduleA and moduleB are alreayd loaded :

> moduleA.echo('test')
echo from A test

> moduleB.add(2, 3)
5

You can even add a #!/usr/env/bin node and do a chmod +x repl.js to call ./repl.js directly and enter your customized interactive shell.

I hope I understood your question correctly, Hope this helps, Séb

I haven't tried this but I suspect this will work.

Add replify to your app, after your other imports
Run the application
Connect to the REPL socket to interact with your app.

I believe this was originally created so you could interact with Node while a web server was running, so you could do live inspection of the contents.

You would need a utility to read/write to the socket, such as socat or nc

You could also add this to a shell script:

#! /bin/sh
node app.js &
nc -U /tmp/repl/realtime-101.sock

For more info: https://github.com/dshaw/replify

@sportebois I actually have a fallow up question for you. How would you do the imports with ES6, say I am using Typescript in the ES6 npm package.

Well, Node can only load js, so you need to transpile your ts first (and make sure you don't use features that aren't yes supported by your Node version, or adjust your transpile options accordingly). But this is the only things required to get it working.

Let's start with the most basic TS config we could think of: tsconfig.json

{
    "compilerOptions": {
        "module": "commonjs",
        "target": "es6",
        "noImplicitAny": false,
        "sourceMap": false
    }
}

Now, let's write a simple TS class, in a file named moduleTS.ts

export class Offset {
    constructor(public qty:Number, public trend:'up'|'down' = 'up' ) {

    }

    public customLog() {
        console.log(`My output: qty:${this.qty}, trend:${this.trend}`);
    }
}

I kept is super simple, but we already have the default public members creation which is specific to TS (at least for now)

Don't forget to add that module to your repl pre-loading: (same script as before, with this one added)
repl.js

const repl = require('repl').start({useGlobal: true});
for (let myModule of ['moduleTS', 'moduleA', 'moduleB']) {
    repl.context[myModule] = require(`./${myModule}`);
}

Last step, don't forget to transpile your TS before to load the module (so that the up-to-date js export is loaded) tsc && node customRepl.js Obviously, if your ts code don'T change often, you don't have to transpile it every single time!

Now, in your Node console, you should be able to use the simple Offset class we created in Typescript:

// Inside Node console
> const tsOffset1 = new moduleTS.Offset(1.2)
undefined
> const tsOffset2 = new moduleTS.Offset(5, 'down')
undefined
> tsOffset1.customLog()
My output: qty:1.2, trend:up
undefined
> tsOffset2.customLog()
My output: qty:5, trend:down
undefined

Does this help?

Yes sir. Sorry I guess I forgot to reply. But thanks to your help I was able to get this launched https://github.com/marcusjwhelan/nedb-shell . Should be useful. But I plan on building more on top of it later. I just needed the initial functionality first.

Thread

I have searched just about the entire internet for this so I am coming to you with a tough one. How do you spawn a node shell with a custom module pre loaded into it.

Responses(2)

Search Hashnode

I have searched just about the entire internet for this so I am coming to you with a tough one. How do you spawn a node shell with a custom module pre loaded into it.

Responses(2)