Export type vs. interface

[eMarek]

I am testing json-schema-to-typescript and I see that in some cases it produces interface and in other cases type. What is the rule here, when does it make which? Is there an option if I would like to use only type?

[bcherny]

Hey, these are generally a little different. Interfaces with the same name will be merged by TSC, which is important for emitting duplicates (otherwise, we’d need to prune these ourselves and build our own type DAG, which can be expensive).

Extensions also work a little different for type vs. interface, and it would be undesirable to have to support semantics for both.

Is there a reason you’re interested in sticking to one vs. both for your use case?

See https://github.com/bcherny/json-schema-to-typescript/blob/master/src/generator.ts for when we emit one vs. the other.

[eMarek]

Interfaces with the same name will be merged by TSC

This is exact reason why I prefer types. I don't want TypeScript to do some under the hood magic which can result into bugs. Imagine that there is an interface somewhere in the code which I am not aware of it and then the same interface will be generated out of JSON schema. Two totally unrelated things will be represented as one.

So there are no plans in the future to pick between interface and type?

[scaleflake]

I agree that there should be an option to choose between interface and type. In my case, the interface don't fit due to this issue: microsoft/TypeScript#15300

[swain]

+1 -- this definitely needs to be configurable somehow. More recent versions of TypeScript have introduced more significant different handling between types + interfaces, so there is definitely semantic difference.

Perhaps a custom JSONSchema attribute could override the default? e.g.

{
  "type": "object",
  "title": "MyType",
  "tsUseType": true
}

I'd be happy to PR this change, if you'd be open to reviewing @bcherny.

[johann1301s]

I suggest dropping interface completely: https://www.youtube.com/watch?v=oiFo2z8ILNo.

[Fleshgrinder]

Moving your properties inside an allOf results in a type being generated instead of an interface. This is an effective way to work around this issue.

interface

{
  "type": "object",
  "properties": {
    // snip
  }
}

type

{
  "allOf": [
    {
      "type": "object",
      "properties": {
        // snip
      }
    }
  }
}

[jgornick]

@bcherny Curious if there is a simple solution to prefer generating types instead of interfaces? I'm happy to make the change if I can be pointed in the right direction.

Thanks!

[sybers]

I'm trying to use this package to generate some nested types and it would be awesome if we could simply retrieve the body of the generated types (i.e. without interface or type).

I basically have multiple JSON Schema definitions which I want to merge together to make a more complex type.

So if you plan on making interface swappable with type, please also consider a third option to not include anything and export the type "body" directly.

Thanks!

[jonyeezs]

Both have their merits. Interface works if you need to make different concrete classes over those schema. Anything else types are more beneficial based off the utility provided by typescript.

I reckon something like the customName to provide the option to set the conversion to type or interface.

IMO the root should only be interface, anything else should be type. But the option above should give everyone the flexibility.

[Gabriele-Tomberli]

I don't like interfaces due to the merging, for now I simply RegEx replace the output of json-schema-to-typescript to use types instead, not sure if there is a better alternative, but it works in my simple use case. A proper configuration would be really useful 🙏 .
Sharing my workaround in case it can help someone:

const result = await json2ts.compileFromFile( jsonFile );
const resultWithTypes = result.replace( /^export interface ([A-Za-z0-9]+) \{\s*$/m, "export type $1 = {" );