@platformatic/sql-graphql 3.0.0-alpha.4 → 3.0.0-alpha.6

package/eslint.config.js

@@ -1,3 +1,3 @@
-'use strict'
+import neostandard from 'neostandard'
 
-module.exports = require('neostandard')({ ts: true })
+export default neostandard({ ts: true })

package/index.js

@@ -1,16 +1,14 @@
-'use strict'
-
-const fp = require('fastify-plugin')
-const constructGraph = require('./lib/entity-to-type')
-const mercurius = require('mercurius')
-const graphql = require('graphql')
-const { mercuriusFederationPlugin } = require('@mercuriusjs/federation')
-const { findNearestString } = require('@platformatic/foundation')
-const establishRelations = require('./lib/relationship')
-const setupSubscriptions = require('./lib/subscriptions')
-const setupTelemetry = require('./lib/telemetry')
-const scalars = require('graphql-scalars')
-const errors = require('./lib/errors')
+import { mercuriusFederationPlugin } from '@mercuriusjs/federation'
+import { findNearestString } from '@platformatic/foundation'
+import fp from 'fastify-plugin'
+import { GraphQLObjectType, GraphQLSchema, GraphQLString, printSchema } from 'graphql'
+import { GraphQLDate, GraphQLDateTime } from 'graphql-scalars'
+import mercurius from 'mercurius'
+import { constructGraph } from './lib/entity-to-type.js'
+import { ErrorPrintingGraphQLSchema } from './lib/errors.js'
+import { establishRelations } from './lib/relationship.js'
+import { setupSubscriptions } from './lib/subscriptions.js'
+import { setupTelemetry } from './lib/telemetry.js'
 
 async function mapperToGraphql (app, opts) {
   const mapper = app.platformatic
@@ -28,19 +26,18 @@ async function mapperToGraphql (app, opts) {
     resolvers,
     loaders,
     federationReplacements,
-    federationMetadata: opts.federationMetadata,
+    federationMetadata: opts.federationMetadata
   }
   const metaMap = new Map()
 
   if (Object.keys(mapper.entities).length === 0) {
     // no schema
-    queryTopFields.hello = { type: graphql.GraphQLString }
+    queryTopFields.hello = { type: GraphQLString }
     resolvers.Query = {
-      hello: () => 'Hello Platformatic!',
+      hello: () => 'Hello Platformatic!'
     }
   } else {
-    const entitiesNames = Object.values(mapper.entities)
-      .map(entity => entity.singularName)
+    const entitiesNames = Object.values(mapper.entities).map(entity => entity.singularName)
 
     for (const ignoredEntity of Object.keys(ignore)) {
       if (!entitiesNames.includes(ignoredEntity)) {
@@ -94,17 +91,18 @@ async function mapperToGraphql (app, opts) {
     }
   }
 
-  const query = new graphql.GraphQLObjectType({
+  const query = new GraphQLObjectType({
     name: 'Query',
-    fields: queryTopFields,
+    fields: queryTopFields
   })
 
-  const mutation = Object.keys(mutationTopFields).length > 0
-    ? new graphql.GraphQLObjectType({
-      name: 'Mutation',
-      fields: mutationTopFields,
-    })
-    : null
+  const mutation =
+    Object.keys(mutationTopFields).length > 0
+      ? new GraphQLObjectType({
+        name: 'Mutation',
+        fields: mutationTopFields
+      })
+      : null
 
   if (!mutation) {
     delete resolvers.Mutation
@@ -130,7 +128,7 @@ async function mapperToGraphql (app, opts) {
 
     if (entitiesList.length > 0) {
       opts.subscription = {
-        emitter: app.platformatic.mq,
+        emitter: app.platformatic.mq
       }
       // TODO support ignoring some of those
       subscription = setupSubscriptions(app, metaMap, resolvers, ignoreList)
@@ -139,14 +137,14 @@ async function mapperToGraphql (app, opts) {
 
   let sdl = ''
   try {
-    sdl = graphql.printSchema(new graphql.GraphQLSchema({ query, mutation, subscription }))
+    sdl = printSchema(new GraphQLSchema({ query, mutation, subscription }))
   } catch (error) {
     // The next lines are excluded from test coverage:
     // it's quite hard to test the following lines for all of the DB types
     /* istanbul ignore next */
     app.log.debug({ query, mutation, subscription }, 'GraphQL input schema')
     /* istanbul ignore next */
-    const newError = new errors.ErrorPrintingGraphQLSchema()
+    const newError = new ErrorPrintingGraphQLSchema()
     /* istanbul ignore next */
     newError.cause = error
     /* istanbul ignore next */
@@ -167,10 +165,10 @@ async function mapperToGraphql (app, opts) {
   // Ignoriring because SQLite doesn't support dates
   /* istanbul ignore next */
   if (sdl.match(/scalar Date\n/)) {
-    resolvers.Date = scalars.GraphQLDate
+    resolvers.Date = GraphQLDate
   }
   if (sdl.indexOf('scalar DateTime') >= 0) {
-    resolvers.DateTime = scalars.GraphQLDateTime
+    resolvers.DateTime = GraphQLDateTime
   }
 
   opts.graphiql = opts.graphiql !== false
@@ -184,7 +182,7 @@ async function mapperToGraphql (app, opts) {
     ...opts,
     schema: sdl,
     loaders,
-    resolvers,
+    resolvers
   })
 
   if (app.openTelemetry) {
@@ -194,5 +192,5 @@ async function mapperToGraphql (app, opts) {
   app.log.debug({ schema: sdl }, 'computed schema')
 }
 
-module.exports = fp(mapperToGraphql)
-module.exports.errors = errors
+export default fp(mapperToGraphql)
+export * as errors from './lib/errors.js'

package/lib/entity-to-type.js

@@ -1,52 +1,48 @@
-'use strict'
-
-const graphql = require('graphql')
-const camelcase = require('camelcase')
-const { findNearestString } = require('@platformatic/foundation')
-const {
-  sqlTypeToGraphQL,
-  fromSelectionSet,
-} = require('./utils')
-const errors = require('./errors')
-
-const ascDesc = new graphql.GraphQLEnumType({
+import { findNearestString } from '@platformatic/foundation'
+import camelcase from 'camelcase'
+import {
+  GraphQLEnumType,
+  GraphQLID,
+  GraphQLInputObjectType,
+  GraphQLInt,
+  GraphQLList,
+  GraphQLNonNull,
+  GraphQLObjectType,
+  GraphQLScalarType
+} from 'graphql'
+import { UnableToGenerateGraphQLEnumTypeError } from './errors.js'
+import { fromSelectionSet, sqlTypeToGraphQL } from './utils.js'
+
+const ascDesc = new GraphQLEnumType({
   name: 'OrderByDirection',
   values: {
     ASC: { value: 'ASC' },
-    DESC: { value: 'DESC' },
-  },
+    DESC: { value: 'DESC' }
+  }
 })
 
-const limitType = new graphql.GraphQLScalarType({
+const limitType = new GraphQLScalarType({
   name: 'LimitInt',
-  description: 'Limit will be applied by default if not passed. If the provided value exceeds the maximum allowed value a validation error will be thrown',
+  description:
+    'Limit will be applied by default if not passed. If the provided value exceeds the maximum allowed value a validation error will be thrown'
 })
 
-function constructGraph (app, entity, opts, ignore) {
-  const primaryKeys = Array.from(entity.primaryKeys).map((key) => camelcase(key))
-  const relationalFields = entity.relations
-    .map((relation) => relation.column_name)
+export function constructGraph (app, entity, opts, ignore) {
+  const primaryKeys = Array.from(entity.primaryKeys).map(key => camelcase(key))
+  const relationalFields = entity.relations.map(relation => relation.column_name)
   const entityName = entity.name
   const singular = entity.singularName
   const plural = entity.pluralName
-  const {
-    queryTopFields,
-    mutationTopFields,
-    resolvers,
-    federationReplacements,
-    federationMetadata,
-    loaders,
-  } = opts
-
-  const entityFieldsNames = Object.values(entity.fields)
-    .map(field => field.camelcase)
+  const { queryTopFields, mutationTopFields, resolvers, federationReplacements, federationMetadata, loaders } = opts
+
+  const entityFieldsNames = Object.values(entity.fields).map(field => field.camelcase)
 
   for (const ignoredField of Object.keys(ignore)) {
     if (!entityFieldsNames.includes(ignoredField)) {
       const nearestField = findNearestString(entityFieldsNames, ignoredField)
       app.log.warn(
-      `Ignored graphql field "${ignoredField}" not found in entity "${entity.singularName}".` +
-      ` Did you mean "${nearestField}"?`
+        `Ignored graphql field "${ignoredField}" not found in entity "${entity.singularName}".` +
+          ` Did you mean "${nearestField}"?`
       )
     }
   }
@@ -66,7 +62,7 @@ function constructGraph (app, entity, opts, ignore) {
     /* istanbul ignore next */
     if (field.isArray) {
       const listType = sqlTypeToGraphQL(field.sqlType)
-      meta.type = new graphql.GraphQLList(listType)
+      meta.type = new GraphQLList(listType)
     } else if (field.enum) {
       const enumValues = field.enum.reduce((acc, enumValue, index) => {
         let key = enumValue.replace(/[^\w]/g, '_')
@@ -85,38 +81,46 @@ function constructGraph (app, entity, opts, ignore) {
       }, {})
       try {
         const name = camelcase([entityName, key])
-        meta.type = new graphql.GraphQLEnumType({ name, values: enumValues })
+        meta.type = new GraphQLEnumType({ name, values: enumValues })
       } catch (error) {
         app.log.error({ key, enumValues, entityName, table: entity.table, schema: entity.schema })
-        throw new errors.UnableToGenerateGraphQLEnumTypeError()
+        throw new UnableToGenerateGraphQLEnumTypeError()
       }
     } else {
       meta.type = sqlTypeToGraphQL(field.sqlType)
     }
     if (field.primaryKey) {
       meta.primaryKeyType = field.type
-      meta.type = graphql.GraphQLID
+      meta.type = GraphQLID
     } else if (field.foreignKey) {
-      meta.type = graphql.GraphQLID
+      meta.type = GraphQLID
     }
     fields[field.camelcase] = meta
   }
 
-  const type = new graphql.GraphQLObjectType({
+  const type = new GraphQLObjectType({
     name: entityName,
-    fields,
+    fields
   })
 
   resolvers.Query = resolvers.Query || {}
   resolvers.Mutation = resolvers.Mutation || {}
   loaders.Query = loaders.Query || {}
 
-  const getBy = camelcase(['get', singular, ...(primaryKeys.map((key, i) => {
-    if (i === 0) {
-      return ['by', key]
-    }
-    return ['and', key]
-  }).flat())].join('_'))
+  const getBy = camelcase(
+    [
+      'get',
+      singular,
+      ...primaryKeys
+        .map((key, i) => {
+          if (i === 0) {
+            return ['by', key]
+          }
+          return ['and', key]
+        })
+        .flat()
+    ].join('_')
+  )
 
   const whereFields = Object.keys(fields).reduce((acc, field) => {
     let graphqlFields
@@ -130,50 +134,52 @@ function constructGraph (app, entity, opts, ignore) {
         lt: { type: fields[field].type },
         lte: { type: fields[field].type },
         like: { type: fields[field].type },
-        in: { type: new graphql.GraphQLList(fields[field].type) },
-        nin: { type: new graphql.GraphQLList(fields[field].type) },
+        in: { type: new GraphQLList(fields[field].type) },
+        nin: { type: new GraphQLList(fields[field].type) }
       }
     } else {
       graphqlFields = {
         any: { type: fields[field].type.ofType },
         all: { type: fields[field].type.ofType },
-        contains: { type: new graphql.GraphQLList(fields[field].type) },
-        contained: { type: new graphql.GraphQLList(fields[field].type) },
-        overlaps: { type: new graphql.GraphQLList(fields[field].type) },
+        contains: { type: new GraphQLList(fields[field].type) },
+        contained: { type: new GraphQLList(fields[field].type) },
+        overlaps: { type: new GraphQLList(fields[field].type) }
       }
     }
     acc[field] = {
-      type: new graphql.GraphQLInputObjectType({
+      type: new GraphQLInputObjectType({
         name: `${entityName}WhereArguments${field}`,
-        fields: graphqlFields,
-      }),
+        fields: graphqlFields
+      })
     }
     return acc
   }, {})
 
-  const whereArgType = new graphql.GraphQLInputObjectType({
+  const whereArgType = new GraphQLInputObjectType({
     name: `${entityName}WhereArguments`,
     fields: {
       ...whereFields,
       or: {
-        type: new graphql.GraphQLList(new graphql.GraphQLInputObjectType({
-          name: `${entityName}WhereArgumentsOr`,
-          fields: {
-            ...whereFields,
-          },
-        })),
-      },
-    },
+        type: new GraphQLList(
+          new GraphQLInputObjectType({
+            name: `${entityName}WhereArgumentsOr`,
+            fields: {
+              ...whereFields
+            }
+          })
+        )
+      }
+    }
   })
 
   queryTopFields[getBy] = {
     type,
     args: {
-      ...(primaryKeys.reduce((acc, primaryKey) => {
-        acc[primaryKey] = { type: new graphql.GraphQLNonNull(fields[primaryKey].type) }
+      ...primaryKeys.reduce((acc, primaryKey) => {
+        acc[primaryKey] = { type: new GraphQLNonNull(fields[primaryKey].type) }
         return acc
-      }, {})),
-    },
+      }, {})
+    }
   }
   loaders.Query[getBy] = {
     loader (queries, ctx) {
@@ -188,49 +194,51 @@ function constructGraph (app, entity, opts, ignore) {
       return loadMany(keys, queries, ctx)
     },
     opts: {
-      cache: false,
-    },
+      cache: false
+    }
   }
 
-  const orderByFields = new graphql.GraphQLEnumType({
+  const orderByFields = new GraphQLEnumType({
     name: `${entityName}OrderByField`,
     values: Object.keys(fields).reduce((acc, field) => {
       /* istanbul ignore else */
       if (!fields[field].isArray) {
         acc[field] = {
-          value: field,
+          value: field
         }
       }
       return acc
-    }, {}),
+    }, {})
   })
   queryTopFields[plural] = {
-    type: new graphql.GraphQLList(type),
+    type: new GraphQLList(type),
     args: {
       limit: { type: limitType },
-      offset: { type: graphql.GraphQLInt },
+      offset: { type: GraphQLInt },
       orderBy: {
-        type: new graphql.GraphQLList(new graphql.GraphQLInputObjectType({
-          name: `${entityName}OrderByArguments`,
-          fields: {
-            field: { type: orderByFields },
-            direction: { type: new graphql.GraphQLNonNull(ascDesc) },
-          },
-        })),
+        type: new GraphQLList(
+          new GraphQLInputObjectType({
+            name: `${entityName}OrderByArguments`,
+            fields: {
+              field: { type: orderByFields },
+              direction: { type: new GraphQLNonNull(ascDesc) }
+            }
+          })
+        )
       },
-      where: { type: whereArgType },
-    },
+      where: { type: whereArgType }
+    }
   }
 
   resolvers.Query[plural] = (_, query, ctx, info) => {
-    const requestedFields = info.fieldNodes[0].selectionSet.selections.map((s) => s.name.value)
+    const requestedFields = info.fieldNodes[0].selectionSet.selections.map(s => s.name.value)
     for (const primaryKey of primaryKeys) {
       requestedFields.push(primaryKey)
     }
     return entity.find({ ...query, fields: [...requestedFields, ...relationalFields], ctx })
   }
 
-  const inputType = new graphql.GraphQLInputObjectType({
+  const inputType = new GraphQLInputObjectType({
     name: `${entityName}Input`,
     fields: Object.keys(fields).reduce((acc, field) => {
       const meta = fields[field]
@@ -239,27 +247,27 @@ function constructGraph (app, entity, opts, ignore) {
         acc[field] = meta
       }
       return acc
-    }, {}),
+    }, {})
   })
 
   const count = camelcase(['count', plural])
 
-  const countType = new graphql.GraphQLObjectType({
+  const countType = new GraphQLObjectType({
     name: `${plural}Count`,
     fields: {
-      total: { type: graphql.GraphQLInt },
-    },
+      total: { type: GraphQLInt }
+    }
   })
 
   queryTopFields[count] = {
     type: countType,
     args: {
-      where: { type: whereArgType },
-    },
+      where: { type: whereArgType }
+    }
   }
 
   resolvers.Query[count] = async (_, query, ctx, info) => {
-    const requestedFields = info.fieldNodes[0].selectionSet.selections.map((s) => s.name.value)
+    const requestedFields = info.fieldNodes[0].selectionSet.selections.map(s => s.name.value)
     for (const primaryKey of primaryKeys) {
       requestedFields.push(primaryKey)
     }
@@ -272,8 +280,8 @@ function constructGraph (app, entity, opts, ignore) {
   mutationTopFields[save] = {
     type,
     args: {
-      input: { type: new graphql.GraphQLNonNull(inputType) },
-    },
+      input: { type: new GraphQLNonNull(inputType) }
+    }
   }
 
   resolvers.Mutation[save] = async (_, { input }, ctx, info) => {
@@ -284,10 +292,10 @@ function constructGraph (app, entity, opts, ignore) {
   const insert = camelcase(['insert', plural])
 
   mutationTopFields[insert] = {
-    type: new graphql.GraphQLList(type),
+    type: new GraphQLList(type),
     args: {
-      inputs: { type: new graphql.GraphQLNonNull(new graphql.GraphQLList(inputType)) },
-    },
+      inputs: { type: new GraphQLNonNull(new GraphQLList(inputType)) }
+    }
   }
 
   resolvers.Mutation[insert] = (_, { inputs }, ctx, info) => {
@@ -297,20 +305,20 @@ function constructGraph (app, entity, opts, ignore) {
 
   const deleteKey = camelcase(['delete', plural])
   mutationTopFields[deleteKey] = {
-    type: new graphql.GraphQLList(type),
+    type: new GraphQLList(type),
     args: {
-      where: { type: whereArgType },
-    },
+      where: { type: whereArgType }
+    }
   }
 
   resolvers.Mutation[deleteKey] = (_, args, ctx, info) => {
-    const fields = info.fieldNodes[0].selectionSet.selections.map((s) => s.name.value)
+    const fields = info.fieldNodes[0].selectionSet.selections.map(s => s.name.value)
     return entity.delete({ ...args, fields: [...fields, ...relationalFields], ctx })
   }
 
   federationReplacements.push({
     find: new RegExp(`type ${entityName}`),
-    replace: `type ${entityName} @key(fields: "${primaryKeys}")`,
+    replace: `type ${entityName} @key(fields: "${primaryKeys}")`
   })
 
   if (federationMetadata) {
@@ -328,8 +336,8 @@ function constructGraph (app, entity, opts, ignore) {
         return loadMany(keys, queries, ctx)
       },
       opts: {
-        cache: false,
-      },
+        cache: false
+      }
     }
   }
 
@@ -339,7 +347,7 @@ function constructGraph (app, entity, opts, ignore) {
     loadMany,
     getFields,
     relationalFields,
-    fields,
+    fields
   }
 
   async function loadMany (keys, queries, ctx) {
@@ -357,7 +365,7 @@ function constructGraph (app, entity, opts, ignore) {
           acc[key].in.push(value)
         } else {
           acc[key] = {
-            in: [value],
+            in: [value]
           }
         }
         return acc
@@ -369,16 +377,14 @@ function constructGraph (app, entity, opts, ignore) {
       where,
       fields,
       limit,
-      ctx,
+      ctx
     })
 
     const matchedRaws = []
     // TODO this is extremely inefficient
     // we need a better data structure
     for (const pair of keys) {
-      const matchedRaw = rows.find((raw) =>
-        pair.every(({ key, value }) => raw[key] === value)
-      ) || null
+      const matchedRaw = rows.find(raw => pair.every(({ key, value }) => raw[key] === value)) || null
       matchedRaws.push(matchedRaw)
     }
 
@@ -397,5 +403,3 @@ function constructGraph (app, entity, opts, ignore) {
     return [...fields]
   }
 }
-
-module.exports = constructGraph

package/lib/errors.js

@@ -1,11 +1,13 @@
-'use strict'
+import createError from '@fastify/error'
 
-const createError = require('@fastify/error')
+export const ERROR_PREFIX = 'PLT_SQL_GRAPHQL'
 
-const ERROR_PREFIX = 'PLT_SQL_GRAPHQL'
-
-module.exports = {
-  UnableToGenerateGraphQLEnumTypeError: createError(`${ERROR_PREFIX}_UNABLE_GENERATE_GRAPHQL_ENUM_TYPE`, 'Unable to generate GraphQLEnumType'),
-  UnsupportedKindError: createError(`${ERROR_PREFIX}_UNSUPPORTED_KIND`, 'Unsupported kind: %s'),
-  ErrorPrintingGraphQLSchema: createError(`${ERROR_PREFIX}_ERROR_PRINTING_GRAPHQL_SCHEMA`, 'Error printing the GraphQL schema'),
-}
+export const UnableToGenerateGraphQLEnumTypeError = createError(
+  `${ERROR_PREFIX}_UNABLE_GENERATE_GRAPHQL_ENUM_TYPE`,
+  'Unable to generate GraphQLEnumType'
+)
+export const UnsupportedKindError = createError(`${ERROR_PREFIX}_UNSUPPORTED_KIND`, 'Unsupported kind: %s')
+export const ErrorPrintingGraphQLSchema = createError(
+  `${ERROR_PREFIX}_ERROR_PRINTING_GRAPHQL_SCHEMA`,
+  'Error printing the GraphQL schema'
+)

package/lib/relationship.js

@@ -1,21 +1,25 @@
-'use strict'
-
 /* eslint camelcase: 0 */
 
-const camelcase = require('camelcase')
-const {
-  fromSelectionSet,
-} = require('./utils')
-const assert = require('assert')
+import assert from 'assert'
+import camelcase from 'camelcase'
+import { fromSelectionSet } from './utils.js'
 
-module.exports = function establishRelations (app, relations, resolvers, loaders, queryTopFields, relationships, metaMap) {
+export function establishRelations (app, relations, resolvers, loaders, queryTopFields, relationships, metaMap) {
   const entitiesTypeMap = {}
   const entities = app.platformatic.entities
   for (const key of Object.keys(entities)) {
     entitiesTypeMap[key] = metaMap.get(entities[key])
   }
   for (const relation of relations) {
-    const { table_name, foreign_table_name, column_name, foreign_column_name, entityName, foreignEntityName, loweredTableWithSchemaName } = relation
+    const {
+      table_name,
+      foreign_table_name,
+      column_name,
+      foreign_column_name,
+      entityName,
+      foreignEntityName,
+      loweredTableWithSchemaName
+    } = relation
     const enhanceAssertLogMsg = `(table: "${table_name}", foreign table: "${foreign_table_name}", column: "${column_name}")`
 
     assert(table_name, `table_name is required ${enhanceAssertLogMsg}`)
@@ -23,7 +27,10 @@ module.exports = function establishRelations (app, relations, resolvers, loaders
 
     const current = entitiesTypeMap[entityName]
     const foreign = entitiesTypeMap[foreignEntityName]
-    assert(foreign !== undefined, `No foreign table named "${foreign_table_name}" was found ${enhanceAssertLogMsg}. Relation: ${JSON.stringify(relation, null, 2)}`)
+    assert(
+      foreign !== undefined,
+      `No foreign table named "${foreign_table_name}" was found ${enhanceAssertLogMsg}. Relation: ${JSON.stringify(relation, null, 2)}`
+    )
 
     // current to foreign, we skip this if the foreign table has a composite primary key
     // TODO implement support for this case
@@ -40,17 +47,15 @@ module.exports = function establishRelations (app, relations, resolvers, loaders
           loader (queries, ctx) {
             const keys = []
             for (const { obj } of queries) {
-              const value = obj[originalField] != null
-                ? obj[originalField].toString()
-                : null
+              const value = obj[originalField] != null ? obj[originalField].toString() : null
 
               keys.push([{ key, value }])
             }
             return foreign.loadMany(keys, queries, ctx)
           },
           opts: {
-            cache: false,
-          },
+            cache: false
+          }
         }
       }
     }
@@ -76,7 +81,10 @@ module.exports = function establishRelations (app, relations, resolvers, loaders
           resolvers[foreign.type][lowered] = async function (obj, args, ctx, info) {
             const previousResponse = await previousResolve(obj, args, ctx, info)
             const currentResponse = await resolveRelation(obj, args, ctx, info)
-            return uniqueBy([...previousResponse, ...currentResponse], findPrimaryColumnName(current.entity.camelCasedFields))
+            return uniqueBy(
+              [...previousResponse, ...currentResponse],
+              findPrimaryColumnName(current.entity.camelCasedFields)
+            )
           }
         }
       }
@@ -109,4 +117,4 @@ function unique (arr) {
 function uniqueBy (arr, key) {
   const uniqueValues = unique(arr.map(el => el[key]))
   return uniqueValues.map(value => arr.find(el => el[key] === value))
-};
+}

package/lib/subscriptions.js

@@ -1,9 +1,7 @@
-'use strict'
+import camelcase from 'camelcase'
+import { GraphQLObjectType } from 'graphql'
 
-const graphql = require('graphql')
-const camelcase = require('camelcase')
-
-function setupSubscriptions (app, metaMap, resolvers, ignores) {
+export function setupSubscriptions (app, metaMap, resolvers, ignores) {
   const fields = {}
   resolvers.Subscription = {}
   for (const [field, meta] of metaMap) {
@@ -21,7 +19,7 @@ function setupSubscriptions (app, metaMap, resolvers, ignores) {
     const { type } = meta
     const saved = `${field.singularName}Saved`
     fields[saved] = {
-      type,
+      type
     }
     resolvers.Subscription[saved] = {
       subscribe: async function * (_, query, ctx, info) {
@@ -54,19 +52,19 @@ function setupSubscriptions (app, metaMap, resolvers, ignores) {
             log.warn({ err, entity: field.singularName }, 'graphql subscription error')
           }
         }
-      },
+      }
     }
 
     const deleted = `${field.singularName}Deleted`
     fields[deleted] = {
-      type: new graphql.GraphQLObjectType({
+      type: new GraphQLObjectType({
         name: `${field.name}Deleted`,
         fields: {
           [primaryKey]: {
-            type: meta.fields[primaryKey].type,
-          },
-        },
-      }),
+            type: meta.fields[primaryKey].type
+          }
+        }
+      })
     }
     resolvers.Subscription[deleted] = {
       subscribe: async (_, query, ctx, info) => {
@@ -75,12 +73,12 @@ function setupSubscriptions (app, metaMap, resolvers, ignores) {
         const res = await pubsub.subscribe(topic)
         ctx.reply.request.log.trace({ topic }, 'subscribed')
         return wrap(res, deleted)
-      },
+      }
     }
   }
-  const subscription = new graphql.GraphQLObjectType({
+  const subscription = new GraphQLObjectType({
     name: 'Subscription',
-    fields,
+    fields
   })
 
   return subscription
@@ -91,5 +89,3 @@ async function * wrap (iterator, key) {
     yield { [key]: msg }
   }
 }
-
-module.exports = setupSubscriptions

package/lib/telemetry.js

@@ -1,33 +1,33 @@
-'use strict'
+function telemetryWrapper (app, fn, operationType, operationName) {
+  return async function (...args) {
+    const { startSpan, endSpan } = app.openTelemetry
+    const context = args[2]
+    const request = context?.reply?.request
+    const document = JSON.stringify(request?.body)
 
-const telemetryWrapper = (app, fn, operationType, operationName) => async (...args) => {
-  const { startSpan, endSpan } = app.openTelemetry
-  const context = args[2]
-  const request = context?.reply?.request
-  const document = JSON.stringify(request?.body)
-
-  // GraphQL semantic conventions, see: https://github.com/open-telemetry/semantic-conventions/blob/main/docs/database/graphql.md#semantic-conventions-for-graphql-server
-  const telemetryAttributes = {
-    'graphql.document': document,
-    'graphql.operation.name': operationName,
-    'graphql.operation.type': operationType,
-  }
-  const spanName = `${operationType} ${operationName}`
-  const ctx = request.span?.context
+    // GraphQL semantic conventions, see: https://github.com/open-telemetry/semantic-conventions/blob/main/docs/database/graphql.md#semantic-conventions-for-graphql-server
+    const telemetryAttributes = {
+      'graphql.document': document,
+      'graphql.operation.name': operationName,
+      'graphql.operation.type': operationType
+    }
+    const spanName = `${operationType} ${operationName}`
+    const ctx = request.span?.context
 
-  const span = startSpan(spanName, ctx, telemetryAttributes)
-  try {
-    const result = await fn(...args)
-    endSpan(span)
-    return result
-  // We ignore this because in sqlite it's HARD to have a resolver exception without a schema validation exception first.
-  } catch (err) /* istanbul ignore next */ {
-    endSpan(span, err)
-    throw err
+    const span = startSpan(spanName, ctx, telemetryAttributes)
+    try {
+      const result = await fn(...args)
+      endSpan(span)
+      return result
+      // We ignore this because in sqlite it's HARD to have a resolver exception without a schema validation exception first.
+    } catch (err) /* istanbul ignore next */ {
+      endSpan(span, err)
+      throw err
+    }
   }
 }
 
-const setupTelemetry = app => {
+export function setupTelemetry (app) {
   /* istanbul ignore next */
   if (!app || !app.graphql) {
     app.log.warn('No graphql plugin found, skipping telemetry setup')
@@ -52,5 +52,3 @@ const setupTelemetry = app => {
     }
   }
 }
-
-module.exports = setupTelemetry

package/lib/utils.js

@@ -1,13 +1,11 @@
-'use strict'
-
-const graphql = require('graphql')
-const scalars = require('graphql-scalars')
-const { GraphQLJSONObject } = require('graphql-type-json')
-const errors = require('./errors')
+import * as graphql from 'graphql'
+import * as scalars from 'graphql-scalars'
+import { GraphQLJSONObject } from 'graphql-type-json'
+import { UnsupportedKindError } from './errors.js'
 
 // The sqlTypeToGraphQL is shared between
 // all database adapters.
-function sqlTypeToGraphQL (sqlType) {
+export function sqlTypeToGraphQL (sqlType) {
   // TODO support more types
   /* istanbul ignore next */
   switch (sqlType) {
@@ -68,7 +66,7 @@ function sqlTypeToGraphQL (sqlType) {
   }
 }
 
-function fromSelectionSet (selectionSet, fields = new Set()) {
+export function fromSelectionSet (selectionSet, fields = new Set()) {
   /* istanbul ignore next */
   for (const s of selectionSet.selections) {
     if (s.kind === 'Field') {
@@ -76,14 +74,10 @@ function fromSelectionSet (selectionSet, fields = new Set()) {
     } else if (s.kind === 'InlineFragment') {
       fromSelectionSet(s.selectionSet, fields)
     } else {
-      throw new errors.UnsupportedKindError(s.kind)
+      throw new UnsupportedKindError(s.kind)
     }
   }
   return fields
 }
 
-module.exports = {
-  sqlTypeToGraphQL,
-  fromSelectionSet,
-  typeSym: Symbol('graphlType'),
-}
+export const typeSym = Symbol('graphlType')

package/package.json

@@ -1,8 +1,9 @@
 {
   "name": "@platformatic/sql-graphql",
-  "version": "3.0.0-alpha.4",
+  "version": "3.0.0-alpha.6",
   "description": "Map SQL dbs to GraphQL",
   "main": "index.js",
+  "type": "module",
   "types": "index.d.ts",
   "repository": {
     "type": "git",
@@ -16,9 +17,8 @@
   "homepage": "https://github.com/platformatic/platformatic#readme",
   "devDependencies": {
     "@matteo.collina/snap": "^0.3.0",
-    "@matteo.collina/tspl": "^0.2.0",
     "@mercuriusjs/gateway": "^5.0.0",
-    "borp": "^0.20.0",
+    "cleaner-spec-reporter": "^0.5.0",
     "eslint": "9",
     "fastify": "^5.0.0",
     "fastify-tsconfig": "^3.0.0",
@@ -27,9 +27,9 @@
     "typescript": "^5.5.4",
     "why-is-node-running": "^2.2.2",
     "ws": "^8.16.0",
-    "@platformatic/sql-events": "3.0.0-alpha.4",
-    "@platformatic/sql-mapper": "3.0.0-alpha.4",
-    "@platformatic/telemetry": "3.0.0-alpha.4"
+    "@platformatic/telemetry": "3.0.0-alpha.6",
+    "@platformatic/sql-mapper": "3.0.0-alpha.6",
+    "@platformatic/sql-events": "3.0.0-alpha.6"
   },
   "dependencies": {
     "@fastify/error": "^4.0.0",
@@ -41,7 +41,7 @@
     "graphql-type-json": "^0.3.2",
     "inflected": "^2.1.0",
     "mercurius": "^16.0.0",
-    "@platformatic/foundation": "3.0.0-alpha.4"
+    "@platformatic/foundation": "3.0.0-alpha.6"
   },
   "tsd": {
     "directory": "test/types"
@@ -51,12 +51,12 @@
   },
   "scripts": {
     "lint": "eslint",
-    "test": "npm run lint && 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 borp --timeout=1200000 --concurrency=1 test/*.test.js",
-    "test:mariadb": "DB=mariadb borp --timeout=1200000 --concurrency=1 test/*.test.js",
-    "test:mysql": "DB=mysql borp --timeout=1200000 --concurrency=1 test/*.test.js",
-    "test:mysql8": "DB=mysql8 borp --timeout=1200000 --concurrency=1 test/*.test.js",
-    "test:sqlite": "DB=sqlite borp --timeout=1200000 --concurrency=1 test/*.test.js",
+    "test": "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 node --test --test-reporter=cleaner-spec-reporter --test-concurrency=1 --test-timeout=2000000 test/*.test.js",
+    "test:mariadb": "DB=mariadb node --test --test-reporter=cleaner-spec-reporter --test-concurrency=1 --test-timeout=2000000 test/*.test.js",
+    "test:mysql": "DB=mysql node --test --test-reporter=cleaner-spec-reporter --test-concurrency=1 --test-timeout=2000000 test/*.test.js",
+    "test:mysql8": "DB=mysql8 node --test --test-reporter=cleaner-spec-reporter --test-concurrency=1 --test-timeout=2000000 test/*.test.js",
+    "test:sqlite": "DB=sqlite node --test --test-reporter=cleaner-spec-reporter --test-concurrency=1 --test-timeout=2000000 test/*.test.js",
     "test:typescript": "tsd"
   }
 }