Expose Polka class

[ghostdevv]

Would it be possible to export the Polka class? Something I am writing would need this.

[v1rtl]

Adding export keyword here

polka/packages/polka/index.js

Line 13 in 431cf70

class Polka extends Router {

would work.

I think it's worth making a PR to next branch

[ghostdevv]

I know, I was more asking if it's something luke would allow. I can make a pr anyway.

[lukeed]

It's more a question of why this is wanted

Traditionally my response to this question has been to not do it, since it exposes the opportunity for people to accidentally do some nasty extensions to Polka and then blame Polka itself.

[lukeed]

There's also already a PR for this: #103

[ghostdevv]

It's more a question of why this is wanted

I wanted to extend Polka to add some features for my use case.

There's also already a PR for this: #103

Awesome

[lukeed]

I wanted to extend Polka to add some features for my use case

Right, to do what? What do you need to add?

[ghostdevv]

Right, to do what? What do you need to add?

I was writing a router that lays on top of polka and extends it's base class to add new functionality, I ended up scraping that idea and instead binding it to polka instead, like this:

import polka from 'polka';
import { router } from 'x'; // Calling it x for this example

const server = polka();
const x = router(server);

[lukeed]

Yeah, I would just wrap it and add the functionality you're looking to add.

You can also instantiate a Polka app via polka() and then read out its constructor, extend it, and then reinstantiate your final class from there. It's ugly, but it's supposed to be. My original point still stands in that protecting the Polka class prevents users from accidentally breaking their applications, which wouldnt be hard to do since all internals are exposed.

Something like this:

const Polka = polka().constructor;

class MyRouter extends Polka {
  constructor(options) {
    super(options);
    // ...other stuff
  }
  foobar() {
    return 'foobar method';
  }
}

let app = new MyRouter({ ... });
app.foobar(); //=> "foobar method"
app.get('/users/:name', reply).listen(PORT);

Ugly, but visually obvious you're doing something off-the-path.
Same thing applies to app.foobar = function () { ... } IMO.

Here's a non-Polka, quick demo:

class Animal {
  walk() {
    return 'walking';
  }
}

class Cat extends Animal {
  #foo = 123;
  change(val) {
    this.#foo = val;
  }
  meow() {
    return `meowing: ${this.#foo}`;
  }
}

let foo = new Cat;
let Ctor = foo.constructor;

class Extra extends Ctor {
  extra() {
    return ('extra')
  }
}

let bar = new Extra();
console.log('meow#1', bar.meow());
//=> meow#1 meowing: 123
console.log('extra', bar.extra());
console.log('walk', bar.walk());

console.log('change', bar.change('asd'));
console.log('meow#2', bar.meow());
//=> meow#2 meowing: asd

Closing for now, as I still don't think this should be done.

[ghostdevv]

Thank you for the alternative, it doesn't matter if it's internally ugly as long as everything still works fine.

Closing for now, as I still don't think this should be done.

I am not quite sure how they could break it in this case as all the polka function does is return a instance of the class, people won't just accidentally extend the class and break something as they would have to know what they are trying to do to import the class in the first place let alone extend it