@platformatic/sql-mapper 3.4.1 → 3.5.0

package/lib/cursor.js

@@ -0,0 +1,94 @@
+import {
+  MissingOrderByClauseError,
+  MissingOrderByFieldForCursorError,
+  MissingUniqueFieldInCursorError,
+  UnknownFieldError
+} from './errors.js'
+
+function sanitizeCursor (cursor, orderBy, inputToFieldMap, fields, primaryKeys) {
+  if (!orderBy || orderBy.length === 0) throw new MissingOrderByClauseError()
+  let hasUniqueField = false
+  const validCursorFields = new Map()
+
+  for (const [key, value] of Object.entries(cursor)) {
+    const dbField = inputToFieldMap[key]
+    if (!dbField) throw new UnknownFieldError(key)
+    const order = orderBy.find(order => order.field === key)
+    if (!order) throw new MissingOrderByFieldForCursorError(key)
+    if (primaryKeys.has(dbField)) hasUniqueField = true
+    validCursorFields.set(key, {
+      dbField,
+      value,
+      direction: order.direction.toLowerCase(),
+      fieldWrap: fields[dbField]
+    })
+  }
+  if (!hasUniqueField) throw new MissingUniqueFieldInCursorError()
+
+  // Process fields in orderBy order
+  const cursorFields = []
+  for (const order of orderBy) {
+    if (validCursorFields.has(order.field)) {
+      cursorFields.push(validCursorFields.get(order.field))
+    }
+  }
+  return cursorFields
+}
+
+function buildTupleQuery (cursorFields, sql, computeCriteriaValue, isBackwardPagination) {
+  const direction = cursorFields[0].direction
+  let operator
+  if (isBackwardPagination) {
+    operator = direction === 'desc' ? '>' : '<'
+  } else {
+    operator = direction === 'desc' ? '<' : '>'
+  }
+  const fields = sql.join(
+    cursorFields.map(({ dbField }) => sql.ident(dbField)),
+    sql`, `
+  )
+  const values = sql.join(
+    cursorFields.map(({ fieldWrap, value }) => computeCriteriaValue(fieldWrap, value)),
+    sql`, `
+  )
+  return sql`(${fields}) ${sql.__dangerous__rawValue(operator)} (${values})`
+}
+
+function buildQuery (cursorFields, sql, computeCriteriaValue, isBackwardPagination) {
+  const conditions = []
+  const equalityParts = []
+  for (const { dbField, fieldWrap, value, direction } of cursorFields) {
+    let operator
+    if (isBackwardPagination) {
+      operator = direction === 'desc' ? '>' : '<'
+    } else {
+      operator = direction === 'desc' ? '<' : '>'
+    }
+    const inequalityPart = sql`${sql.ident(dbField)} ${sql.__dangerous__rawValue(operator)} ${computeCriteriaValue(fieldWrap, value)}`
+    if (equalityParts.length === 0) {
+      conditions.push(inequalityPart)
+    } else {
+      conditions.push(sql`${sql.join(equalityParts, sql` AND `)} AND ${inequalityPart}`)
+    }
+    equalityParts.push(sql`${sql.ident(dbField)} = ${computeCriteriaValue(fieldWrap, value)}`)
+  }
+  return sql`(${sql.join(conditions, sql` OR `)})`
+}
+
+export function buildCursorCondition (
+  sql,
+  cursor,
+  orderBy,
+  inputToFieldMap,
+  fields,
+  computeCriteriaValue,
+  primaryKeys,
+  isBackwardPagination
+) {
+  if (!cursor || Object.keys(cursor).length === 0) return null
+  const cursorFields = sanitizeCursor(cursor, orderBy, inputToFieldMap, fields, primaryKeys)
+  const sameSortDirection = cursorFields.every(({ direction }) => direction === cursorFields[0].direction)
+  return sameSortDirection
+    ? buildTupleQuery(cursorFields, sql, computeCriteriaValue, isBackwardPagination)
+    : buildQuery(cursorFields, sql, computeCriteriaValue, isBackwardPagination)
+}

package/lib/entity.js

@@ -1,19 +1,36 @@
-'use strict'
-
-const camelcase = require('camelcase')
-const {
-  toSingular,
-  toUpperFirst,
-  toLowerFirst,
-  tableName,
-  sanitizeLimit,
-} = require('./utils')
-const { singularize } = require('inflected')
-const { findNearestString } = require('@platformatic/utils')
-const errors = require('./errors')
-const { wrapDB } = require('./telemetry')
-
-function createMapper (defaultDb, sql, log, table, fields, primaryKeys, relations, queries, autoTimestamp, schema, useSchemaInName, limitConfig, columns, constraintsList) {
+import { findNearestString } from '@platformatic/foundation'
+import camelcase from 'camelcase'
+import { singularize } from 'inflected'
+import { buildCursorCondition } from './cursor.js'
+import {
+  InputNotProvidedError,
+  InvalidPrimaryKeyTypeError,
+  MissingWhereClauseError,
+  ParamNotAllowedError,
+  UnknownFieldError,
+  UnsupportedOperatorForArrayFieldError,
+  UnsupportedOperatorForNonArrayFieldError,
+  UnsupportedWhereClauseError
+} from './errors.js'
+import { wrapDB } from './telemetry.js'
+import { sanitizeLimit, tableName, toLowerFirst, toSingular, toUpperFirst } from './utils.js'
+
+function createMapper (
+  defaultDb,
+  sql,
+  log,
+  table,
+  fields,
+  primaryKeys,
+  relations,
+  queries,
+  autoTimestamp,
+  schema,
+  useSchemaInName,
+  limitConfig,
+  columns,
+  constraintsList
+) {
   /* istanbul ignore next */ // Ignoring because this won't be fully covered by DB not supporting schemas (SQLite)
   const entityName = useSchemaInName ? toUpperFirst(`${schema}${toSingular(table)}`) : toSingular(table)
   /* istanbul ignore next */
@@ -22,7 +39,7 @@ function createMapper (defaultDb, sql, log, table, fields, primaryKeys, relation
 
   // If the db is in the opts, uses it, otherwise uses the defaultDb
   // if telemetry is enabled, wraps the db with telemetry
-  const getDB = (opts) => {
+  const getDB = opts => {
     let db = opts?.tx || defaultDb
     if (opts?.ctx?.app?.openTelemetry && opts?.ctx?.reply?.request) {
       const req = opts.ctx.reply.request
@@ -43,10 +60,10 @@ function createMapper (defaultDb, sql, log, table, fields, primaryKeys, relation
     return acc
   }, {})
 
-  const primaryKeysTypes = Array.from(primaryKeys).map((key) => {
+  const primaryKeysTypes = Array.from(primaryKeys).map(key => {
     return {
       key,
-      sqlType: fields[key].sqlType,
+      sqlType: fields[key].sqlType
     }
   })
 
@@ -59,7 +76,7 @@ function createMapper (defaultDb, sql, log, table, fields, primaryKeys, relation
         if (fields[key] !== undefined) {
           newKey = key
         } else {
-          throw new errors.UnknownFieldError(key)
+          throw new UnknownFieldError(key)
         }
       }
       newInput[newKey] = value
@@ -86,10 +103,10 @@ function createMapper (defaultDb, sql, log, table, fields, primaryKeys, relation
   async function save (args) {
     const db = getDB(args)
     if (args.input === undefined) {
-      throw new errors.InputNotProvidedError()
+      throw new InputNotProvidedError()
     }
     // args.input is not array
-    const fieldsToRetrieve = computeFields(args.fields).map((f) => sql.ident(f))
+    const fieldsToRetrieve = computeFields(args.fields).map(f => sql.ident(f))
     const input = fixInput(args.input)
 
     let hasPrimaryKeys = true
@@ -105,7 +122,8 @@ function createMapper (defaultDb, sql, log, table, fields, primaryKeys, relation
       now = new Date()
       input[autoTimestamp.updatedAt] = now
     }
-    if (hasPrimaryKeys) { // update
+    if (hasPrimaryKeys) {
+      // update
       const res = await queries.updateOne(db, sql, table, schema, input, primaryKeys, fieldsToRetrieve)
       if (res) {
         return fixOutput(res)
@@ -127,7 +145,7 @@ function createMapper (defaultDb, sql, log, table, fields, primaryKeys, relation
 
   async function insert (args) {
     const db = getDB(args)
-    const fieldsToRetrieve = computeFields(args.fields).map((f) => sql.ident(f))
+    const fieldsToRetrieve = computeFields(args.fields).map(f => sql.ident(f))
     const inputs = args.inputs
     // This else is skipped on MySQL because of https://github.com/ForbesLindesay/atdatabases/issues/221
     /* istanbul ignore else */
@@ -145,7 +163,17 @@ function createMapper (defaultDb, sql, log, table, fields, primaryKeys, relation
     /* istanbul ignore next */
     if (queries.insertMany) {
       // We are not fixing the input here because it is done in the query.
-      const res = await queries.insertMany(db, sql, table, schema, inputs, inputToFieldMap, primaryKeysTypes, fieldsToRetrieve, fields)
+      const res = await queries.insertMany(
+        db,
+        sql,
+        table,
+        schema,
+        inputs,
+        inputToFieldMap,
+        primaryKeysTypes,
+        fieldsToRetrieve,
+        fields
+      )
       return res.map(fixOutput)
     } else {
       // TODO this can be optimized, we can still use a batch insert if we do not want any fields
@@ -162,13 +190,13 @@ function createMapper (defaultDb, sql, log, table, fields, primaryKeys, relation
 
   async function updateMany (args) {
     if (args.input === undefined) {
-      throw new errors.InputNotProvidedError()
+      throw new InputNotProvidedError()
     }
     if (args.where === undefined || Object.keys(args.where).length === 0) {
-      throw new errors.MissingWhereClauseError()
+      throw new MissingWhereClauseError()
     }
     const db = getDB(args)
-    const fieldsToRetrieve = computeFields(args.fields).map((f) => sql.ident(f))
+    const fieldsToRetrieve = computeFields(args.fields).map(f => sql.ident(f))
     const input = fixInput(args.input)
     if (autoTimestamp && fields[autoTimestamp.updatedAt]) {
       const now = new Date()
@@ -189,9 +217,9 @@ function createMapper (defaultDb, sql, log, table, fields, primaryKeys, relation
      * The 'field' can be a relational field which is undefined
      * in the inputToFieldMap
      * @see sql-graphql
-    */
-    const requestedFields = fields.map((field) => {
-      if (relations.some((relation) => field === relation.column_name)) {
+     */
+    const requestedFields = fields.map(field => {
+      if (relations.some(relation => field === relation.column_name)) {
         return field
       }
       return inputToFieldMap[field]
@@ -218,7 +246,7 @@ function createMapper (defaultDb, sql, log, table, fields, primaryKeys, relation
     all: 'ALL',
     contains: '@>',
     contained: '<@',
-    overlaps: '&&',
+    overlaps: '&&'
   }
 
   function computeCriteria (opts) {
@@ -237,14 +265,14 @@ function createMapper (defaultDb, sql, log, table, fields, primaryKeys, relation
       const value = where[key]
       const field = inputToFieldMap[key]
       if (!field) {
-        throw new errors.UnknownFieldError(key)
+        throw new UnknownFieldError(key)
       }
       for (const key of Object.keys(value)) {
         const operator = whereMap[key]
         /* istanbul ignore next */
         if (!operator) {
           // This should never happen
-          throw new errors.UnsupportedWhereClauseError(JSON.stringify(where[key]))
+          throw new UnsupportedWhereClauseError(JSON.stringify(where[key]))
         }
         const fieldWrap = fields[field]
         /* istanbul ignore next */
@@ -260,7 +288,7 @@ function createMapper (defaultDb, sql, log, table, fields, primaryKeys, relation
           } else if (operator === '&&') {
             criteria.push(sql`${sql.ident(field)} && ${value[key]}`)
           } else {
-            throw new errors.UnsupportedOperatorForArrayFieldError()
+            throw new UnsupportedOperatorForArrayFieldError()
           }
         } else if (operator === '=' && value[key] === null) {
           criteria.push(sql`${sql.ident(field)} IS NULL`)
@@ -275,10 +303,18 @@ function createMapper (defaultDb, sql, log, table, fields, primaryKeys, relation
           }
           const like = operator === 'LIKE' ? sql`LIKE` : queries.hasILIKE ? sql`ILIKE` : sql`LIKE`
           criteria.push(sql`${leftHand} ${like} ${value[key]}`)
-        } else if (operator === 'ANY' || operator === 'ALL' || operator === '@>' || operator === '<@' || operator === '&&') {
-          throw new errors.UnsupportedOperatorForNonArrayFieldError()
+        } else if (
+          operator === 'ANY' ||
+          operator === 'ALL' ||
+          operator === '@>' ||
+          operator === '<@' ||
+          operator === '&&'
+        ) {
+          throw new UnsupportedOperatorForNonArrayFieldError()
         } else {
-          criteria.push(sql`${sql.ident(field)} ${sql.__dangerous__rawValue(operator)} ${computeCriteriaValue(fieldWrap, value[key])}`)
+          criteria.push(
+            sql`${sql.ident(field)} ${sql.__dangerous__rawValue(operator)} ${computeCriteriaValue(fieldWrap, value[key])}`
+          )
         }
       }
     }
@@ -288,13 +324,18 @@ function createMapper (defaultDb, sql, log, table, fields, primaryKeys, relation
   function computeCriteriaValue (fieldWrap, value) {
     if (Array.isArray(value)) {
       return sql`(${sql.join(
-        value.map((v) => computeCriteriaValue(fieldWrap, v)),
+        value.map(v => computeCriteriaValue(fieldWrap, v)),
         sql`, `
       )})`
     }
 
     /* istanbul ignore next */
-    if (fieldWrap.sqlType === 'int4' || fieldWrap.sqlType === 'int2' || fieldWrap.sqlType === 'float8' || fieldWrap.sqlType === 'float4') {
+    if (
+      fieldWrap.sqlType === 'int4' ||
+      fieldWrap.sqlType === 'int2' ||
+      fieldWrap.sqlType === 'float8' ||
+      fieldWrap.sqlType === 'float4'
+    ) {
       // This cat is needed in PostgreSQL
       return sql`${Number(value)}`
     } else {
@@ -304,37 +345,62 @@ function createMapper (defaultDb, sql, log, table, fields, primaryKeys, relation
 
   async function find (opts = {}) {
     const db = getDB(opts)
-    const fieldsToRetrieve = computeFields(opts.fields).map((f) => sql.ident(f))
+    const fieldsToRetrieve = computeFields(opts.fields).map(f => sql.ident(f))
     const criteria = computeCriteria(opts)
+    const criteriaExists = criteria.length > 0
+    const isBackwardPagination = opts.nextPage === false
 
     let query = sql`
       SELECT ${sql.join(fieldsToRetrieve, sql`, `)}
       FROM ${tableName(sql, table, schema)}
     `
 
-    if (criteria.length > 0) {
+    if (criteriaExists) {
       query = sql`${query} WHERE ${sql.join(criteria, sql` AND `)}`
     }
 
+    if (opts.cursor) {
+      const cursorCondition = buildCursorCondition(
+        sql,
+        opts.cursor,
+        opts.orderBy,
+        inputToFieldMap,
+        fields,
+        computeCriteriaValue,
+        primaryKeys,
+        isBackwardPagination
+      )
+      if (cursorCondition) {
+        if (criteriaExists) query = sql`${query} AND ${cursorCondition}`
+        else query = sql`${query} WHERE ${cursorCondition}`
+      }
+    }
+
     if (opts.orderBy && opts.orderBy.length > 0) {
-      const orderBy = opts.orderBy.map((order) => {
+      const orderBy = opts.orderBy.map(order => {
         const field = inputToFieldMap[order.field]
-        return sql`${sql.ident(field)} ${sql.__dangerous__rawValue(order.direction)}`
+        let direction = order.direction.toLowerCase()
+        if (isBackwardPagination) {
+          direction = direction === 'asc' ? 'desc' : 'asc'
+        }
+        return sql`${sql.ident(field)} ${sql.__dangerous__rawValue(direction)}`
       })
       query = sql`${query} ORDER BY ${sql.join(orderBy, sql`, `)}`
     }
 
-    query = sql`${query} LIMIT ${sanitizeLimit(opts.limit, limitConfig)}`
-    if (opts.offset !== undefined) {
-      if (opts.offset < 0) {
-        throw new errors.ParamNotAllowedError(opts.offset)
+    if (opts.paginate !== false) {
+      query = sql`${query} LIMIT ${sanitizeLimit(opts.limit, limitConfig)}`
+      if (opts.offset !== undefined) {
+        if (opts.offset < 0) {
+          throw new ParamNotAllowedError(opts.offset)
+        }
+        query = sql`${query} OFFSET ${opts.offset}`
       }
-      query = sql`${query} OFFSET ${opts.offset}`
     }
 
     const rows = await db.query(query)
     const res = rows.map(fixOutput)
-    return res
+    return isBackwardPagination ? res.reverse() : res
   }
 
   async function count (opts = {}) {
@@ -354,7 +420,7 @@ function createMapper (defaultDb, sql, log, table, fields, primaryKeys, relation
 
   async function _delete (opts) {
     const db = getDB(opts)
-    const fieldsToRetrieve = computeFields(opts.fields).map((f) => sql.ident(f))
+    const fieldsToRetrieve = computeFields(opts.fields).map(f => sql.ident(f))
     const criteria = computeCriteria(opts)
     const res = await queries.deleteAll(db, sql, table, schema, criteria, fieldsToRetrieve)
     return res.map(fixOutput)
@@ -376,11 +442,25 @@ function createMapper (defaultDb, sql, log, table, fields, primaryKeys, relation
     insert,
     save,
     delete: _delete,
-    updateMany,
+    updateMany
   }
 }
 
-function buildEntity (db, sql, log, table, queries, autoTimestamp, schema, useSchemaInName, ignore, limitConfig, schemaList, columns, constraintsList) {
+export function buildEntity (
+  db,
+  sql,
+  log,
+  table,
+  queries,
+  autoTimestamp,
+  schema,
+  useSchemaInName,
+  ignore,
+  limitConfig,
+  schemaList,
+  columns,
+  constraintsList
+) {
   const columnsNames = columns.map(c => c.column_name)
   for (const ignoredColumn of Object.keys(ignore)) {
     if (!columnsNames.includes(ignoredColumn)) {
@@ -390,21 +470,26 @@ function buildEntity (db, sql, log, table, queries, autoTimestamp, schema, useSc
   }
 
   // Compute the columns
-  columns = columns.filter((c) => !ignore[c.column_name])
+  columns = columns.filter(c => !ignore[c.column_name])
   const fields = columns.reduce((acc, column) => {
     acc[column.column_name] = {
       sqlType: column.udt_name,
       isNullable: column.is_nullable === 'YES',
-      isArray: column.isArray,
+      isArray: column.isArray
     }
 
     // To get enum values in mysql and mariadb
     /* istanbul ignore next */
     if (column.udt_name === 'enum') {
-      acc[column.column_name].enum = column.column_type.match(/'(.+?)'/g).map(enumValue => enumValue.slice(1, enumValue.length - 1))
+      acc[column.column_name].enum = column.column_type
+        .match(/'(.+?)'/g)
+        .map(enumValue => enumValue.slice(1, enumValue.length - 1))
     }
 
-    if (autoTimestamp && (column.column_name === autoTimestamp.createdAt || column.column_name === autoTimestamp.updatedAt)) {
+    if (
+      autoTimestamp &&
+      (column.column_name === autoTimestamp.createdAt || column.column_name === autoTimestamp.updatedAt)
+    ) {
       acc[column.column_name].autoTimestamp = true
     }
 
@@ -437,7 +522,7 @@ function buildEntity (db, sql, log, table, queries, autoTimestamp, schema, useSc
       const validTypes = ['varchar', 'integer', 'uuid', 'serial']
       const pkType = fields[constraint.column_name].sqlType.toLowerCase()
       if (!validTypes.includes(pkType)) {
-        throw new errors.InvalidPrimaryKeyTypeError(pkType, validTypes.join(', '))
+        throw new InvalidPrimaryKeyTypeError(pkType, validTypes.join(', '))
       }
     }
   }
@@ -448,9 +533,12 @@ function buildEntity (db, sql, log, table, queries, autoTimestamp, schema, useSc
     /* istanbul ignore next */
     if (!field) {
       // This should never happen
-      log.warn({
-        constraint,
-      }, `No field for ${constraint.column_name}`)
+      log.warn(
+        {
+          constraint
+        },
+        `No field for ${constraint.column_name}`
+      )
       continue
     }
 
@@ -463,13 +551,28 @@ function buildEntity (db, sql, log, table, queries, autoTimestamp, schema, useSc
 
     // we need to ignore for coverage here because cannot be covered with sqlite (no schema support)
     // istanbul ignore next
-    const isForeignKeySchemaInConfig = schemaList?.length > 0 ? schemaList.includes(constraint.foreign_table_schema) : true
+    const isForeignKeySchemaInConfig =
+      schemaList?.length > 0 ? schemaList.includes(constraint.foreign_table_schema) : true
     /* istanbul ignore if */
     if (constraint.constraint_type === 'FOREIGN KEY' && isForeignKeySchemaInConfig) {
       field.foreignKey = true
-      const foreignEntityName = singularize(camelcase(useSchemaInName ? camelcase(`${constraint.foreign_table_schema} ${constraint.foreign_table_name}`) : constraint.foreign_table_name))
-      const entityName = singularize(camelcase(useSchemaInName ? camelcase(`${constraint.table_schema} ${constraint.table_name}`) : constraint.table_name))
-      const loweredTableWithSchemaName = toLowerFirst(useSchemaInName ? camelcase(`${constraint.table_schema} ${camelcase(constraint.table_name)}`) : camelcase(constraint.table_name))
+      const foreignEntityName = singularize(
+        camelcase(
+          useSchemaInName
+            ? camelcase(`${constraint.foreign_table_schema} ${constraint.foreign_table_name}`)
+            : constraint.foreign_table_name
+        )
+      )
+      const entityName = singularize(
+        camelcase(
+          useSchemaInName ? camelcase(`${constraint.table_schema} ${constraint.table_name}`) : constraint.table_name
+        )
+      )
+      const loweredTableWithSchemaName = toLowerFirst(
+        useSchemaInName
+          ? camelcase(`${constraint.table_schema} ${camelcase(constraint.table_name)}`)
+          : camelcase(constraint.table_name)
+      )
       constraint.loweredTableWithSchemaName = loweredTableWithSchemaName
       constraint.foreignEntityName = foreignEntityName
       constraint.entityName = entityName
@@ -504,10 +607,21 @@ function buildEntity (db, sql, log, table, queries, autoTimestamp, schema, useSc
     }
   }
 
-  const entity = createMapper(db, sql, log, table, fields, primaryKeys, currentRelations, queries, autoTimestamp, schema, useSchemaInName, limitConfig)
+  const entity = createMapper(
+    db,
+    sql,
+    log,
+    table,
+    fields,
+    primaryKeys,
+    currentRelations,
+    queries,
+    autoTimestamp,
+    schema,
+    useSchemaInName,
+    limitConfig
+  )
   entity.relations = currentRelations
 
   return entity
 }
-
-module.exports = buildEntity

package/lib/errors.js

@@ -1,24 +1,68 @@
-'use strict'
+import createError from '@fastify/error'
 
-const createError = require('@fastify/error')
+export const ERROR_PREFIX = 'PLT_SQL_MAPPER'
 
-const ERROR_PREFIX = 'PLT_SQL_MAPPER'
-
-module.exports = {
-  CannotFindEntityError: createError(`${ERROR_PREFIX}_CANNOT_FIND_ENTITY`, 'Cannot find entity %s'),
-  SpecifyProtocolError: createError(`${ERROR_PREFIX}_SPECIFY_PROTOCOLS`, 'You must specify either postgres, mysql or sqlite as protocols'),
-  ConnectionStringRequiredError: createError(`${ERROR_PREFIX}_CONNECTION_STRING_REQUIRED`, 'connectionString is required'),
-  TableMustBeAStringError: createError(`${ERROR_PREFIX}_TABLE_MUST_BE_A_STRING`, 'Table must be a string, got %s'),
-  UnknownFieldError: createError(`${ERROR_PREFIX}_UNKNOWN_FIELD`, 'Unknown field %s'),
-  InputNotProvidedError: createError(`${ERROR_PREFIX}_INPUT_NOT_PROVIDED`, 'Input not provided.'),
-  UnsupportedWhereClauseError: createError(`${ERROR_PREFIX}_UNSUPPORTED_WHERE_CLAUSE`, 'Unsupported where clause %s'),
-  UnsupportedOperatorForArrayFieldError: createError(`${ERROR_PREFIX}_UNSUPPORTED_OPERATOR`, 'Unsupported operator for Array field'),
-  UnsupportedOperatorForNonArrayFieldError: createError(`${ERROR_PREFIX}_UNSUPPORTED_OPERATOR_FOR_NON_ARRAY`, 'Unsupported operator for non Array field'),
-  ParamNotAllowedError: createError(`${ERROR_PREFIX}_PARAM_NOT_ALLOWED`, 'Param offset=%s not allowed. It must be not negative value.'),
-  InvalidPrimaryKeyTypeError: createError(`${ERROR_PREFIX}_INVALID_PRIMARY_KEY_TYPE`, 'Invalid Primary Key type: "%s". We support the following: %s'),
-  ParamLimitNotAllowedError: createError(`${ERROR_PREFIX}_PARAM_LIMIT_NOT_ALLOWED`, 'Param limit=%s not allowed. Max accepted value %s.'),
-  ParamLimitMustBeNotNegativeError: createError(`${ERROR_PREFIX}_PARAM_LIMIT_MUST_BE_NOT_NEGATIVE`, 'Param limit=%s not allowed. It must be a not negative value.'),
-  MissingValueForPrimaryKeyError: createError(`${ERROR_PREFIX}_MISSING_VALUE_FOR_PRIMARY_KEY`, 'Missing value for primary key %s'),
-  MissingWhereClauseError: createError(`${ERROR_PREFIX}_MISSING_WHERE_CLAUSE`, 'Missing where clause', 400),
-  SQLiteOnlySupportsAutoIncrementOnOneColumnError: createError(`${ERROR_PREFIX}_SQLITE_ONLY_SUPPORTS_AUTO_INCREMENT_ON_ONE_COLUMN`, 'SQLite only supports autoIncrement on one column'),
-}
+export const CannotFindEntityError = createError(`${ERROR_PREFIX}_CANNOT_FIND_ENTITY`, 'Cannot find entity %s')
+export const SpecifyProtocolError = createError(
+  `${ERROR_PREFIX}_SPECIFY_PROTOCOLS`,
+  'You must specify either postgres, mysql or sqlite as protocols'
+)
+export const ConnectionStringRequiredError = createError(
+  `${ERROR_PREFIX}_CONNECTION_STRING_REQUIRED`,
+  'connectionString is required'
+)
+export const TableMustBeAStringError = createError(
+  `${ERROR_PREFIX}_TABLE_MUST_BE_A_STRING`,
+  'Table must be a string, got %s'
+)
+export const UnknownFieldError = createError(`${ERROR_PREFIX}_UNKNOWN_FIELD`, 'Unknown field %s')
+export const InputNotProvidedError = createError(`${ERROR_PREFIX}_INPUT_NOT_PROVIDED`, 'Input not provided.')
+export const UnsupportedWhereClauseError = createError(
+  `${ERROR_PREFIX}_UNSUPPORTED_WHERE_CLAUSE`,
+  'Unsupported where clause %s'
+)
+export const UnsupportedOperatorForArrayFieldError = createError(
+  `${ERROR_PREFIX}_UNSUPPORTED_OPERATOR`,
+  'Unsupported operator for Array field'
+)
+export const UnsupportedOperatorForNonArrayFieldError = createError(
+  `${ERROR_PREFIX}_UNSUPPORTED_OPERATOR_FOR_NON_ARRAY`,
+  'Unsupported operator for non Array field'
+)
+export const ParamNotAllowedError = createError(
+  `${ERROR_PREFIX}_PARAM_NOT_ALLOWED`,
+  'Param offset=%s not allowed. It must be not negative value.'
+)
+export const InvalidPrimaryKeyTypeError = createError(
+  `${ERROR_PREFIX}_INVALID_PRIMARY_KEY_TYPE`,
+  'Invalid Primary Key type: "%s". We support the following: %s'
+)
+export const ParamLimitNotAllowedError = createError(
+  `${ERROR_PREFIX}_PARAM_LIMIT_NOT_ALLOWED`,
+  'Param limit=%s not allowed. Max accepted value %s.'
+)
+export const ParamLimitMustBeNotNegativeError = createError(
+  `${ERROR_PREFIX}_PARAM_LIMIT_MUST_BE_NOT_NEGATIVE`,
+  'Param limit=%s not allowed. It must be a not negative value.'
+)
+export const MissingValueForPrimaryKeyError = createError(
+  `${ERROR_PREFIX}_MISSING_VALUE_FOR_PRIMARY_KEY`,
+  'Missing value for primary key %s'
+)
+export const MissingWhereClauseError = createError(`${ERROR_PREFIX}_MISSING_WHERE_CLAUSE`, 'Missing where clause', 400)
+export const SQLiteOnlySupportsAutoIncrementOnOneColumnError = createError(
+  `${ERROR_PREFIX}_SQLITE_ONLY_SUPPORTS_AUTO_INCREMENT_ON_ONE_COLUMN`,
+  'SQLite only supports autoIncrement on one column'
+)
+export const MissingOrderByClauseError = createError(
+  `${ERROR_PREFIX}_MISSING_ORDER_BY_CLAUSE`,
+  'Missing orderBy clause'
+)
+export const MissingOrderByFieldForCursorError = createError(
+  `${ERROR_PREFIX}_MISSING_ORDER_BY_FIELD_FOR_CURSOR`,
+  'Cursor field(s) %s must be included in orderBy'
+)
+export const MissingUniqueFieldInCursorError = createError(
+  `${ERROR_PREFIX}_MISSING_UNIQUE_FIELD_IN_CURSOR`,
+  'Cursor must contain at least one primary key field'
+)

package/lib/queries/index.js

@@ -1,23 +1,4 @@
-'use strict'
-
-/* istanbul ignore file */
-
-const obj = {}
-
-Object.defineProperty(obj, 'pg', {
-  get: () => require('./pg'),
-})
-
-Object.defineProperty(obj, 'mysql', {
-  get: () => require('./mysql'),
-})
-
-Object.defineProperty(obj, 'mariadb', {
-  get: () => require('./mariadb'),
-})
-
-Object.defineProperty(obj, 'sqlite', {
-  get: () => require('./sqlite'),
-})
-
-module.exports = obj
+export * as mariadb from './mariadb.js'
+export * as mysql from './mysql.js'
+export * as pg from './pg.js'
+export * as sqlite from './sqlite.js'