Utilize inherited interface properties in implemented types for graphql operations

Question

Utilize inherited interface properties in implemented types for graphql operations

I am working with an interface called Book that includes 10 fields in TypeScript:

interface Book {
 field1: String
 field2: String
 field3: String
 # it has 10 fields
}

Now, I want to implement this interface in 10 different types without having to manually copy and paste all the fields. Is there a way to do this efficiently?

For instance, is there a shortcut like the following:

type textBook implements Book{
  ...Book Fields
}

node.js express graphql apollo-server

Answer 1

Answer №1

When it comes to avoiding repetition in syntax, there isn't a straightforward solution. If an interface defines a field, each implementing type must explicitly define that field. One option is to use graphql-tag for creating type definitions and utilize interpolation to reduce redundancy. However, the trade-off here is decreased code readability, which may not be worth it in the long run. Additionally, this approach limits your ability to store type definitions in separate .graphql files.


const sharedFields = `
  a: String
  b: String
`
const typeDefs = gql`
  type A {
    ${sharedFields}
  }
  type B {
    ${sharedFields}
  }
`

If the shared fields are conceptually related, another strategy could be to group them into a separate type.


interface Book {
  bookFields: BookFields
}

type BookFields {
  field1: String
  field2: String
  field3: String
  # etc.
}

Answer 2

When it comes to avoiding repetition in syntax, there isn't a straightforward solution. If an interface defines a field, each implementing type must explicitly define that field. One option is to use graphql-tag for creating type definitions and utilize interpolation to reduce redundancy. However, the trade-off here is decreased code readability, which may not be worth it in the long run. Additionally, this approach limits your ability to store type definitions in separate .graphql files.


const sharedFields = `
  a: String
  b: String
`
const typeDefs = gql`
  type A {
    ${sharedFields}
  }
  type B {
    ${sharedFields}
  }
`

If the shared fields are conceptually related, another strategy could be to group them into a separate type.


interface Book {
  bookFields: BookFields
}

type BookFields {
  field1: String
  field2: String
  field3: String
  # etc.
}

Utilize inherited interface properties in implemented types for graphql operations

Answer №1

Similar questions

Display the variance in values present in an array using Node.js

Storing JWT securely in cookie or local storage for a Node.js/Angular 2 web application

Discovering old (potentially neglected) npm dependencies: strategies for locating outdated packages

Looking to retrieve country, state, city, and area based on inputting a pincode value using Node.js?

Exploring multipart uploads in Express JS 4: Leveraging body parser and dicer for efficient file handling

Enable the upsert option in MongoDB Mongoose Collection.findAndModify: true

Renew Firebase Token

Encountering a socket's unavailability due to pre-bind connection

Implementing a notification system similar to Stack Overflow in a Node.js and MongoDB application

Sending JSON data back to the client from a Node.js server

CommunicationsError on Socket.io server

Circular Reference: When a model has multiple owners in a belongsTo relationship

Sending both files and JSON data in a single request using the express framework in Node.js

Displaying the data from a database on a browser using node.js, MySQL, and Jade

Guiding towards the correct form depending on which button is selected

View the list of cron jobs in PM2

Setting up Babel to effectively function across multiple directories

Encountering a gyp error while trying to run npm install on Ubuntu

How are objects typically created in Node.js applications?

The console.log for a GET request in Express Router is displaying undefined parameters