@platformatic/sql-mapper 0.31.0 → 0.32.0

package/README.md

@@ -1,6 +1,6 @@
 # @platformatic/sql-mapper
 
-Check out the full documentation on [our website](https://oss.platformatic.dev/docs/reference/sql-mapper/introduction).
+Check out the full documentation on [our website](https://docs.platformatic.dev/docs/reference/sql-mapper/introduction).
 
 ## Install
 

package/lib/entity.js

@@ -199,7 +199,9 @@ function createMapper (defaultDb, sql, log, table, fields, primaryKeys, relation
     gte: '>=',
     lt: '<',
     lte: '<=',
-    like: 'LIKE'
+    like: 'LIKE',
+    any: 'ANY',
+    all: 'ALL'
   }
 
   function computeCriteria (opts) {
@@ -225,7 +227,17 @@ function createMapper (defaultDb, sql, log, table, fields, primaryKeys, relation
           throw new Error(`Unsupported where clause ${JSON.stringify(where[key])}`)
         }
         const fieldWrap = fields[field]
-        if (operator === '=' && value[key] === null) {
+
+        /* istanbul ignore next */
+        if (fieldWrap.isArray) {
+          if (operator === 'ANY') {
+            criteria.push(sql`${value[key]} = ANY (${sql.ident(field)})`)
+          } else if (operator === 'ALL') {
+            criteria.push(sql`${value[key]} = ALL (${sql.ident(field)})`)
+          } else {
+            throw new Error('Unsupported operator for Array field')
+          }
+        } else if (operator === '=' && value[key] === null) {
           criteria.push(sql`${sql.ident(field)} IS NULL`)
         } else if (operator === '<>' && value[key] === null) {
           criteria.push(sql`${sql.ident(field)} IS NOT NULL`)
@@ -237,6 +249,8 @@ function createMapper (defaultDb, sql, log, table, fields, primaryKeys, relation
             leftHand = sql`TRIM(CAST(${sql.ident(field)} AS CHAR(64)))`
           }
           criteria.push(sql`${leftHand} LIKE ${value[key]}`)
+        } else if (operator === 'ANY' || operator === 'ALL') {
+          throw new Error('Unsupported operator for non Array field')
         } else {
           criteria.push(sql`${sql.ident(field)} ${sql.__dangerous__rawValue(operator)} ${computeCriteriaValue(fieldWrap, value[key])}`)
         }
@@ -292,8 +306,9 @@ function createMapper (defaultDb, sql, log, table, fields, primaryKeys, relation
       query = sql`${query} OFFSET ${opts.offset}`
     }
 
-    const res = await db.query(query)
-    return res.map(fixOutput)
+    const rows = await db.query(query)
+    const res = rows.map(fixOutput)
+    return res
   }
 
   async function count (opts = {}) {
@@ -345,7 +360,8 @@ function buildEntity (db, sql, log, table, queries, autoTimestamp, schema, useSc
   const fields = columns.reduce((acc, column) => {
     acc[column.column_name] = {
       sqlType: column.udt_name,
-      isNullable: column.is_nullable === 'YES'
+      isNullable: column.is_nullable === 'YES',
+      isArray: column.isArray
     }
 
     // To get enum values in mysql and mariadb

package/lib/queries/pg.js

@@ -43,12 +43,32 @@ async function listTables (db, sql, schemas) {
 module.exports.listTables = listTables
 
 async function listColumns (db, sql, table, schema) {
+  /*
   return db.query(sql`
     SELECT column_name, udt_name, is_nullable, is_generated
     FROM information_schema.columns
     WHERE table_name = ${table}
     AND table_schema = ${schema}
   `)
+  */
+
+  const res = await db.query(sql`
+    SELECT column_name, udt_name, is_nullable, is_generated, data_type
+    FROM information_schema.columns
+    WHERE table_name = ${table}
+    AND table_schema = ${schema}
+  `)
+
+  for (const col of res) {
+    if (col.data_type === 'ARRAY') {
+      col.udt_name = col.udt_name.replace(/^_/, '')
+      col.isArray = true
+    } else {
+      col.isArray = false
+    }
+  }
+
+  return res
 }
 
 module.exports.listColumns = listColumns

package/lib/queries/shared.js

@@ -22,9 +22,11 @@ async function insertOne (db, sql, table, schema, input, primaryKeysTypes, field
     sql`, `
   )
   const values = sql.join(
-    Object.keys(input).map((key) => sql.value(input[key])),
-    sql`, `
-  )
+    Object.keys(input).map((key) => {
+      const val = input[key]
+      return sql.value(val)
+    }), sql`, `)
+
   const insert = sql`
     INSERT INTO ${tableName(sql, table, schema)} (${keys})
     VALUES (${values})
@@ -79,7 +81,7 @@ function insertPrep (inputs, inputToFieldMap, fields, sql) {
 
       let value = input[key] ?? input[newKey]
 
-      if (value && typeof value === 'object' && !(value instanceof Date)) {
+      if (value && !fields[newKey].isArray && typeof value === 'object' && !(value instanceof Date)) {
         // This is a JSON field
         value = JSON.stringify(value)
       }

package/mapper.d.ts

@@ -242,13 +242,14 @@ export interface Entity<EntityFields = any> {
   count: Count,
 }
 
+type EntityHook<T extends (...args: any) => any> = (original: T, ...options: Parameters<T>) => ReturnType<T>;
 
 export interface EntityHooks<EntityFields = any> {
-  find?: Find<EntityFields>,
-  insert?: Insert<EntityFields>,
-  save?: Save<EntityFields>,
-  delete?: Delete<EntityFields>,
-  count?: Count,
+  find?: EntityHook<Find<EntityFields>>,
+  insert?: EntityHook<Insert<EntityFields>>,
+  save?: EntityHook<Save<EntityFields>>,
+  delete?: EntityHook<Delete<EntityFields>>,
+  count?: EntityHook<Count>,
 }
 
 export interface SQLMapperPluginOptions {
@@ -304,7 +305,7 @@ export interface SQLMapperPluginInterface {
   /**
    * Adds hooks to the entity.
    */
-  addEntityHooks(entityName: string, hooks: EntityHooks): any
+  addEntityHooks<EntityFields>(entityName: string, hooks: EntityHooks<EntityFields>): any
 }
 
 // Extend the PlatformaticApp interface,
@@ -326,7 +327,7 @@ declare module '@platformatic/types' {
     /**
      * Adds hooks to the entity.
      */
-    addEntityHooks(entityName: string, hooks: EntityHooks): any
+    addEntityHooks<EntityFields>(entityName: string, hooks: EntityHooks<EntityFields>): any
   }
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@platformatic/sql-mapper",
-  "version": "0.31.0",
+  "version": "0.32.0",
   "description": "A data mapper utility for SQL databases",
   "main": "mapper.js",
   "types": "mapper.d.ts",
@@ -22,14 +22,14 @@
     "tsd": "^0.28.1"
   },
   "dependencies": {
-    "@databases/mysql": "^5.2.1",
+    "@databases/mysql": "^6.0.0",
     "@databases/pg": "^5.4.1",
     "@databases/sql": "^3.3.0",
     "@matteo.collina/sqlite-pool": "^0.3.0",
     "camelcase": "^6.3.0",
     "fastify-plugin": "^4.5.0",
     "inflected": "^2.1.0",
-    "@platformatic/types": "0.31.0"
+    "@platformatic/types": "0.32.0"
   },
   "tsd": {
     "directory": "test/types"

package/test/entity.test.js

@@ -1,10 +1,10 @@
 'use strict'
 
 const { test } = require('tap')
-
 const { clear, connInfo, isSQLite, isMysql, isPg, isMysql8 } = require('./helper')
 const { connect } = require('..')
 const fakeLogger = {
+  // trace: (...args) => { console.log(JSON.stringify(args, null, 2)) },
   trace: () => {},
   error: () => {}
 }
@@ -1019,3 +1019,86 @@ test('nested transactions', async ({ equal, same, teardown, rejects }) => {
     same(insertResult, { id: '1', theTitle: null })
   })
 })
+
+test('array support (PG)', { skip: !(isPg) }, async ({ teardown, same, rejects }) => {
+  async function onDatabaseLoad (db, sql) {
+    await clear(db, sql)
+    teardown(() => db.dispose())
+
+    await db.query(sql`CREATE TABLE generated_test (
+      id SERIAL PRIMARY KEY,
+      checkmark BOOLEAN NOT NULL DEFAULT true,
+      test INTEGER[]
+    );`)
+  }
+
+  const mapper = await connect({
+    connectionString: connInfo.connectionString,
+    log: fakeLogger,
+    onDatabaseLoad,
+    ignore: {},
+    hooks: {}
+  })
+
+  const generatedTest = mapper.entities.generatedTest
+
+  // save - new record
+  same(await generatedTest.save({
+    input: { test: [1, 2, 3], checkmark: true }
+  }), { id: 1, test: [1, 2, 3], checkmark: true })
+
+  // save - update
+  same(await generatedTest.save({
+    input: { id: 1, test: [4, 5, 6], checkmark: true }
+  }), { id: 1, test: [4, 5, 6], checkmark: true })
+
+  // insert
+  same(await generatedTest.insert({
+    inputs: [{ test: [4], checkmark: true }]
+  }), [{ id: 2, test: [4], checkmark: true }])
+
+  // where any
+  same(await generatedTest.find({
+    where: {
+      test: { any: 4 }
+    }
+  }), [{ id: 1, test: [4, 5, 6], checkmark: true }, { id: 2, test: [4], checkmark: true }])
+
+  // where all
+  same(await generatedTest.find({
+    where: {
+      test: { all: 4 }
+    }
+  }), [{ id: 2, test: [4], checkmark: true }])
+
+  // where eq
+  await rejects(generatedTest.find({
+    where: {
+      test: { eq: 4 }
+    }
+  }))
+
+  // where any to non-array
+  await rejects(generatedTest.find({
+    where: {
+      checkmark: { any: 4 }
+    }
+  }))
+
+  // where any to non-array
+  await rejects(generatedTest.find({
+    where: {
+      checkmark: { all: 4 }
+    }
+  }))
+
+  // updateMany
+  same(await generatedTest.updateMany({
+    where: {
+      checkmark: { eq: true }
+    },
+    input: {
+      test: [8]
+    }
+  }), [{ id: 1, test: [8], checkmark: true }, { id: 2, test: [8], checkmark: true }])
+})

package/test/types/mapper.test-d.ts

@@ -8,7 +8,6 @@ import {
   Entity,
   DBEntityField,
   Database,
-  WhereCondition,
   SQLMapperPluginInterface,
   EntityHooks,
 } from '../../mapper'
@@ -16,7 +15,6 @@ import {
 const pluginOptions: SQLMapperPluginInterface = await connect({ connectionString: '' })
 expectType<Database>(pluginOptions.db)
 expectType<SQL>(pluginOptions.sql)
-expectType<(entityName: string, hooks: EntityHooks) => any>(pluginOptions.addEntityHooks)
 expectType<{ [entityName: string]: Entity }>(pluginOptions.entities)
 
 interface EntityFields {
@@ -42,11 +40,11 @@ expectType<Partial<EntityFields>[]>(await entity.delete())
 expectType<number>(await entity.count())
 
 const entityHooks: EntityHooks = {
-  async find(options: any): Promise<any[]> { return [] },
-  async insert(options: { inputs: any[], fields?: string[] }): Promise<any[]> { return [] },
-  async save(options: { input: any, fields?: string[] }): Promise<any> { return {} },
-  async delete(options?: { where: WhereCondition, fields: string[] }): Promise<any[]> { return [] },
-  async count(options?: { where?: WhereCondition }): Promise<number> { return 0 },
+  async find(originalFind: typeof entity.find, ...options: Parameters<typeof entity.find>): ReturnType<typeof entity.find> { return [] },
+  async insert(originalInsert: typeof entity.insert, ...options: Parameters<typeof entity.insert>): ReturnType<typeof entity.insert> { return [] },
+  async save(originalSave: typeof entity.save, ...options: Parameters<typeof entity.save>): ReturnType<typeof entity.save> { return {} },
+  async delete(originalDelete: typeof entity.delete, ...options: Parameters<typeof entity.delete>): ReturnType<typeof entity.delete> { return [] },
+  async count(originalCount: typeof entity.count, ...options: Parameters<typeof entity.count>): ReturnType<typeof entity.count> { return 0 },
 }
 expectType<EntityHooks>(entityHooks)
 expectType<SQLMapperPluginInterface>(await connect({ connectionString: '' }))
@@ -74,6 +72,18 @@ const instance: FastifyInstance = fastify()
 instance.register(plugin, { connectionString: '', autoTimestamp: true })
 instance.register((instance) => { 
   expectType<SQLMapperPluginInterface>(instance.platformatic)
+
+  instance.platformatic.addEntityHooks<EntityFields>('something', {
+    async find (originalFind, options) {
+      expectType<Partial<EntityFields>[]>(await originalFind())
+      expectType<Parameters<typeof entity.find>[0]>(options)
+
+      return [{
+        id: 42
+      }]
+    }
+  })
+
   instance.get('/', async (request, reply) => {
     const ctx = request.platformaticContext
     expectType<FastifyInstance>(ctx.app)