@platformatic/sql-graphql 0.0.23

package/lib/entity-to-type.js

@@ -0,0 +1,248 @@
+'use strict'
+
+const graphql = require('graphql')
+const camelcase = require('camelcase')
+const {
+  sqlTypeToGraphQL,
+  fromSelectionSet
+} = require('./utils')
+
+const ascDesc = new graphql.GraphQLEnumType({
+  name: 'OrderByDirection',
+  values: {
+    ASC: { value: 'ASC' },
+    DESC: { value: 'DESC' }
+  }
+})
+
+function constructGraph (app, entity, opts) {
+  const primaryKey = entity.primaryKey
+
+  const entityName = entity.name
+  const singular = entity.singularName
+  const plural = entity.pluralName
+
+  const {
+    queryTopFields,
+    mutationTopFields,
+    resolvers,
+    federationReplacements,
+    federationMetadata,
+    loaders
+  } = opts
+
+  const fields = {}
+
+  for (const key of Object.keys(entity.fields)) {
+    const field = entity.fields[key]
+    const meta = { field }
+    meta.type = sqlTypeToGraphQL(field.sqlType)
+    if (field.primaryKey) {
+      meta.primaryKeyType = field.type
+      meta.type = graphql.GraphQLID
+    } else if (field.foreignKey) {
+      meta.type = graphql.GraphQLID
+    }
+    fields[field.camelcase] = meta
+  }
+
+  const type = new graphql.GraphQLObjectType({
+    name: entityName,
+    fields
+  })
+
+  resolvers.Query = resolvers.Query || {}
+  resolvers.Mutation = resolvers.Mutation || {}
+  loaders.Query = loaders.Query || {}
+
+  const getBy = camelcase(['get', singular, 'by', primaryKey])
+
+  const whereArgType = new graphql.GraphQLInputObjectType({
+    name: `${entityName}WhereArguments`,
+    fields: Object.keys(fields).reduce((acc, field) => {
+      acc[field] = {
+        type: new graphql.GraphQLInputObjectType({
+          name: `${entityName}WhereArguments${field}`,
+          fields: {
+            eq: { type: fields[field].type },
+            neq: { type: fields[field].type },
+            gt: { type: fields[field].type },
+            gte: { type: fields[field].type },
+            lt: { type: fields[field].type },
+            lte: { type: fields[field].type },
+            in: { type: new graphql.GraphQLList(fields[field].type) },
+            nin: { type: new graphql.GraphQLList(fields[field].type) }
+          }
+        })
+      }
+      return acc
+    }, {})
+  })
+
+  queryTopFields[getBy] = {
+    type,
+    args: {
+      [primaryKey]: { type: new graphql.GraphQLNonNull(fields[primaryKey].type) }
+    }
+  }
+  loaders.Query[getBy] = {
+    loader (queries, ctx) {
+      const keys = []
+      for (const query of queries) {
+        keys.push(query.params[primaryKey])
+      }
+      return loadMany(keys, queries, ctx)
+    },
+    opts: {
+      cache: false
+    }
+  }
+
+  const orderByFields = new graphql.GraphQLEnumType({
+    name: `${entityName}OrderByField`,
+    values: Object.keys(fields).reduce((acc, field) => {
+      acc[field] = {
+        value: field
+      }
+      return acc
+    }, {})
+  })
+  queryTopFields[plural] = {
+    type: new graphql.GraphQLList(type),
+    args: {
+      limit: { type: graphql.GraphQLInt },
+      offset: { type: graphql.GraphQLInt },
+      orderBy: {
+        type: new graphql.GraphQLList(new graphql.GraphQLInputObjectType({
+          name: `${entityName}OrderByArguments`,
+          fields: {
+            field: { type: orderByFields },
+            direction: { type: new graphql.GraphQLNonNull(ascDesc) }
+          }
+        }))
+      },
+      where: { type: whereArgType }
+    }
+  }
+
+  resolvers.Query[plural] = (_, query, ctx, info) => {
+    const requestedFields = info.fieldNodes[0].selectionSet.selections.map((s) => s.name.value)
+    requestedFields.push(primaryKey)
+    return entity.find({ ...query, fields: requestedFields, ctx })
+  }
+
+  const inputType = new graphql.GraphQLInputObjectType({
+    name: `${entityName}Input`,
+    fields: Object.keys(fields).reduce((acc, field) => {
+      const meta = fields[field]
+      const actualField = meta.field
+      if (!actualField.autoTimestamp) {
+        acc[field] = meta
+      }
+      return acc
+    }, {})
+  })
+
+  const save = camelcase(['save', singular])
+
+  mutationTopFields[save] = {
+    type,
+    args: {
+      input: { type: new graphql.GraphQLNonNull(inputType) }
+    }
+  }
+
+  resolvers.Mutation[save] = async (_, { input }, ctx, info) => {
+    const fields = fromSelectionSet(info.fieldNodes[0].selectionSet)
+    return entity.save({ input, ctx, fields: [...fields] })
+  }
+
+  const insert = camelcase(['insert', plural])
+
+  mutationTopFields[insert] = {
+    type: new graphql.GraphQLList(type),
+    args: {
+      inputs: { type: new graphql.GraphQLNonNull(new graphql.GraphQLList(inputType)) }
+    }
+  }
+
+  resolvers.Mutation[insert] = (_, { inputs }, ctx, info) => {
+    const fields = fromSelectionSet(info.fieldNodes[0].selectionSet)
+    return entity.insert({ inputs, ctx, fields: [...fields] })
+  }
+
+  const deleteKey = camelcase(['delete', plural])
+  mutationTopFields[deleteKey] = {
+    type: new graphql.GraphQLList(type),
+    args: {
+      where: { type: whereArgType }
+    }
+  }
+
+  resolvers.Mutation[deleteKey] = (_, args, ctx, info) => {
+    const fields = info.fieldNodes[0].selectionSet.selections.map((s) => s.name.value)
+    return entity.delete({ ...args, fields, ctx })
+  }
+
+  federationReplacements.push({
+    find: new RegExp(`type ${entityName}`),
+    replace: `type ${entityName} @key(fields: "${primaryKey}")`
+  })
+
+  if (federationMetadata) {
+    loaders[entityName] = loaders[entityName] || {}
+    loaders[entityName].__resolveReference = {
+      loader (queries, ctx) {
+        const keys = queries.map(({ obj }) => obj[primaryKey])
+        return loadMany(keys, queries, ctx)
+      },
+      opts: {
+        cache: false
+      }
+    }
+  }
+
+  return {
+    type,
+    entity,
+    loadMany,
+    fields
+  }
+
+  async function loadMany (keys, queries, ctx) {
+    const fields = getFields(queries)
+    const res = await entity.find({
+      where: {
+        [primaryKey]: {
+          in: keys
+        }
+      },
+      fields,
+      ctx
+    })
+
+    const map = {}
+
+    for (const row of res) {
+      map[row[primaryKey]] = row
+    }
+
+    const output = []
+    for (const key of keys) {
+      output.push(map[key])
+    }
+
+    return output
+  }
+
+  function getFields (queries) {
+    const fields = new Set()
+    fields.add(primaryKey)
+    for (const query of queries) {
+      fromSelectionSet(query.info.fieldNodes[0].selectionSet, fields)
+    }
+    return [...fields]
+  }
+}
+
+module.exports = constructGraph

package/lib/relationship.js

@@ -0,0 +1,67 @@
+'use strict'
+
+const camelcase = require('camelcase')
+const {
+  fromSelectionSet
+} = require('./utils')
+const assert = require('assert')
+
+module.exports = function establishRelations (app, relations, resolvers, loaders, queryTopFields, relationships, metaMap) {
+  const tablesTypeMap = {}
+  const entities = app.platformatic.entities
+  for (const key of Object.keys(entities)) {
+    const entity = entities[key]
+    tablesTypeMap[entity.table] = metaMap.get(entity)
+  }
+  for (const relation of relations) {
+    assert(relation.table_name, 'table_name is required')
+    assert(relation.foreign_table_name, 'foreign_table_name is required')
+
+    const current = tablesTypeMap[relation.table_name]
+    const foreign = tablesTypeMap[relation.foreign_table_name]
+    assert(foreign !== undefined, `No foreign table named "${relation.foreign_table_name}" was found`)
+
+    // current to foreign
+    {
+      const lowered = lowerCaseFirst(foreign.type)
+      if (!relationships[current.type] || relationships[current.type][lowered] !== false) {
+        current.fields[lowered] = { type: foreign.type }
+        const originalField = camelcase(relation.column_name)
+        delete current.fields[originalField]
+        loaders[current.type] = resolvers[current.type] || {}
+        loaders[current.type][lowered] = {
+          loader (queries, ctx) {
+            const keys = queries.map(({ obj }) => {
+              return obj[originalField]
+            })
+            return foreign.loadMany(keys, queries, ctx)
+          },
+          opts: {
+            cache: false
+          }
+        }
+      }
+    }
+
+    // foreign to current
+    {
+      const lowered = lowerCaseFirst(camelcase(current.entity.table))
+      if (!relationships[foreign.type] || relationships[foreign.type][lowered] !== false) {
+        foreign.fields[lowered] = queryTopFields[lowered]
+        resolvers[foreign.type] = resolvers[foreign.type] || {}
+        resolvers[foreign.type][lowered] = async function (obj, args, ctx, info) {
+          const fields = fromSelectionSet(info.fieldNodes[0].selectionSet, new Set())
+          const toSearch = { ...args, fields: [...fields], ctx }
+          toSearch.where = toSearch.where || {}
+          toSearch.where[camelcase(relation.column_name)] = { eq: obj.id }
+          return current.entity.find(toSearch)
+        }
+      }
+    }
+  }
+}
+
+function lowerCaseFirst (str) {
+  str = str.toString()
+  return str.charAt(0).toLowerCase() + str.slice(1)
+}

package/lib/utils.js

@@ -0,0 +1,77 @@
+'use strict'
+
+const graphql = require('graphql')
+const scalars = require('graphql-scalars')
+
+// The sqlTypeToGraphQL is shared between
+// all database adapters.
+function sqlTypeToGraphQL (sqlType) {
+  // TODO support more types
+  /* istanbul ignore next */
+  switch (sqlType) {
+    case 'int':
+      return graphql.GraphQLInt
+    case 'integer':
+      return graphql.GraphQLInt
+    case 'tinyint':
+      return graphql.GraphQLBoolean
+    case 'smallint':
+      return graphql.GraphQLInt
+    case 'decimal':
+      return graphql.GraphQLInt
+    case 'bigint':
+      return graphql.GraphQLInt
+    case 'int2':
+      return graphql.GraphQLInt
+    case 'int4':
+      return graphql.GraphQLInt
+    case 'varchar':
+      return graphql.GraphQLString
+    case 'text':
+      return graphql.GraphQLString
+    case 'bool':
+      return graphql.GraphQLBoolean
+    case 'real':
+      return graphql.GraphQLFloat
+    case 'float8':
+      return graphql.GraphQLFloat
+    case 'double':
+      return graphql.GraphQLFloat
+    case 'double precision':
+      return graphql.GraphQLFloat
+    case 'numeric':
+      return graphql.GraphQLFloat
+    case 'float4':
+      return graphql.GraphQLFloat
+    case 'date':
+      return scalars.GraphQLDate
+    case 'time':
+      return graphql.GraphQLString
+    case 'timestamp':
+      return scalars.GraphQLDateTime
+    case 'uuid':
+      return graphql.GraphQLString
+    default:
+      return graphql.GraphQLString
+  }
+}
+
+function fromSelectionSet (selectionSet, fields = new Set()) {
+  /* istanbul ignore next */
+  for (const s of selectionSet.selections) {
+    if (s.kind === 'Field') {
+      fields.add(s.name.value)
+    } else if (s.kind === 'InlineFragment') {
+      fromSelectionSet(s.selectionSet, fields)
+    } else {
+      throw new Error('Unsupported kind: ' + s.kind)
+    }
+  }
+  return fields
+}
+
+module.exports = {
+  sqlTypeToGraphQL,
+  fromSelectionSet,
+  typeSym: Symbol('graphlType')
+}

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "@platformatic/sql-graphql",
+  "version": "0.0.23",
+  "description": "Map SQL dbs to GraphQL",
+  "main": "index.js",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/plaformatic/platformatic.git"
+  },
+  "author": "Matteo Collina <hello@matteocollina.com>",
+  "license": "Apache-2.0",
+  "bugs": {
+    "url": "https://github.com/plaformatic/platformatic/issues"
+  },
+  "homepage": "https://github.com/plaformatic/platformatic#readme",
+  "devDependencies": {
+    "@platformatic/sql-mapper": "0.0.23",
+    "fastify": "^4.6.0",
+    "snazzy": "^9.0.0",
+    "standard": "^17.0.0",
+    "tap": "^16.0.0",
+    "tsd": "^0.24.0"
+  },
+  "dependencies": {
+    "camelcase": "^6.0.0",
+    "fastify-plugin": "^4.1.0",
+    "graphql": "^16.6.0",
+    "graphql-scalars": "^1.13.1",
+    "inflected": "^2.1.0",
+    "mercurius": "^11.0.0"
+  },
+  "tsd": {
+    "directory": "test/types"
+  },
+  "scripts": {
+    "test": "standard | snazzy && npm run test:typescript && npm run test:postgresql && npm run test:mariadb && npm run test:mysql && npm run test:mysql8 && npm run test:sqlite",
+    "test:postgresql": "DB=postgresql tap test/*.test.js",
+    "test:mariadb": "DB=mariadb tap test/*.test.js",
+    "test:mysql": "DB=mysql tap test/*.test.js",
+    "test:mysql8": "DB=mysql8 tap test/*.test.js",
+    "test:sqlite": "DB=sqlite tap test/*.test.js",
+    "test:typescript": "tsd"
+  }
+}