@live-change/image-service 0.2.32 → 0.2.35

package/clientConfig.js

@@ -0,0 +1,24 @@
+const definition = require('./definition.js')
+
+const config = definition.config
+const uploadConfig = config.upload || {}
+
+const {
+  maxUploadSize = 10 * 1024 * 1024,
+  maxUploadWidth = 2048,
+  maxUploadHeight = 2048,
+  maxProcessableSize = 50 * 1024 * 1025,
+  maxProcessableWidth = 10000,
+  maxProcessableHeight = 10000,
+  maxProcessablePixels = 6000*6000
+} = uploadConfig
+
+definition.clientConfig = {
+  maxUploadSize,
+  maxUploadWidth,
+  maxUploadHeight,
+  maxProcessableSize,
+  maxProcessableWidth,
+  maxProcessableHeight,
+  maxProcessablePixels
+}

package/endpoint.js

@@ -1,8 +1,151 @@
 const app = require("@live-change/framework").app()
 const definition = require('./definition.js')
 
-const storageDir = `./storage/images/`
-const uploadsDir = `./uploads/`
+const { Image } = require('./image.js')
+
+const fs = require("fs")
+const path = require("path")
+const sharp = require('sharp')
+
+const config = definition.config
+
+const imagesPath = config.imagesPath || `./storage/images/`
+
+function normalizeFormat(f1) {
+  f1 = f1.toLowerCase().trim()
+  if(f1 == 'jpg') f1 = 'jpeg'
+  return f1
+}
+
+function isFormatsIdentical(f1, f2) {
+  return normalizeFormat(f1) == normalizeFormat(f2)
+}
+
+function fileExists(fn) {
+  return new Promise((resolve, reject) => {
+    fs.access(fn, fs.F_OK, (err) => {
+      resolve(!err)
+    })
+  })
+}
+
+function delay(ms) {
+  return new Promise((resolve, reject) => setTimeout(resolve, ms))
+}
+async function getImageMetadata(image, version) {
+  for(let t = 0; t < 5; t++) {
+    const metadata = await Image.get(image)
+    console.log("MD", metadata)
+    if(metadata) return metadata
+    await delay(200 * Math.pow(2, t))
+  }
+  return null
+}
+
+function sanitizeImageId(id) {
+  return id.replace(/[^a-zA-Z0-9\[\]@\.-]/g,"_")
+}
+
+async function handleImageGet(req, res, params) {
+  const { image } = params
+  const metadata = await getImageMetadata(image)
+  console.log("PIC METADATA", image, "=>", metadata)
+  if(!metadata) {
+    res.status(404)
+    res.send("Image " + image + " not found")
+    return
+  }
+  const imagePrefix = imagesPath + sanitizeImageId(image) + '/'
+  const sourceFilePath = path.resolve(imagePrefix + 'original.' + metadata.extension)
+  console.log("SOURCE IMAGE PATH", sourceFilePath)
+  if(!(await fileExists(sourceFilePath))) {
+    res.status(404)
+    console.error("IMAGE FILE NOT FOUND", sourceFilePath)
+    res.send("Image file not found")
+    return
+  }
+
+  const kernel = "lanczos3"
+
+  switch(params.type) {
+    case "original": {
+      if(params.format && !isFormatsIdentical(params.format, metadata.extension)) {
+        console.log("CONVERTING IMAGE!", metadata.extension, params.format)
+        const normalized = normalizeFormat(params.format)
+        const convertedFilePath = path.resolve(imagePrefix + 'converted.' + normalized)
+        if(!(await fileExists(convertedFilePath))) {
+          await sharp(sourceFilePath).toFile(convertedFilePath)
+        }
+        res.sendFile(convertedFilePath)
+      } else res.sendFile(sourceFilePath)
+    } break;
+    case "width": {
+      const width = +params.width
+      if(!(width > 0)) {
+        res.status(400)
+        res.send("Bad parameter value")
+        return
+      }
+      //if(width > metadata.original.width) return res.sendFile(sourceFilePath)
+      const normalized = normalizeFormat(params.format || metadata.extension)
+      const convertedFilePath = path.resolve(imagePrefix + `width-${width}.${normalized}`)
+      if(!(await fileExists(convertedFilePath))) {
+        await sharp(sourceFilePath)
+            .resize({
+              width,
+              kernel
+            })
+            .toFile(convertedFilePath)
+      }
+      res.sendFile(convertedFilePath)
+    } break;
+    case "height": {
+      const height = +params.height
+      if(!(height > 0)) {
+        res.status(400)
+        res.send("Bad parameter value")
+        return
+      }
+      //if(height > metadata.original.height) return res.sendFile(sourceFilePath)
+      const normalized = normalizeFormat(params.format || metadata.extension)
+      const convertedFilePath = path.resolve(imagePrefix + `height-${height}.${normalized}`)
+      if(!(await fileExists(convertedFilePath))) {
+        await sharp(sourceFilePath)
+            .resize({
+              height,
+              kernel
+            })
+            .toFile(convertedFilePath)
+      }
+      res.sendFile(convertedFilePath)
+    } break;
+    case "rect": {
+      const width = +params.width
+      const height = +params.height
+      if(!(height > 0 && width>0)) {
+        res.status(400)
+        res.send("Bad parameter value")
+        return
+      }
+      //if(height > metadata.original.height) return res.sendFile(sourceFilePath)
+      //if(width > metadata.original.width) return res.sendFile(sourceFilePath)
+      const normalized = normalizeFormat(params.format || metadata.extension)
+      const convertedFilePath = path.resolve(imagePrefix + `rect-${width}-${height}.${normalized}`)
+      if(!(await fileExists(convertedFilePath))) {
+        await sharp(sourceFilePath)
+            .resize({
+              width, height,
+              fit: sharp.fit.cover,
+              position: sharp.strategy.attention,
+              kernel
+            })
+            .toFile(convertedFilePath)
+      }
+      res.sendFile(convertedFilePath)
+    }
+  }
+}
+
 
 const express = require("express")
 
@@ -10,39 +153,34 @@ definition.endpoint({
   name: 'image',
   create() {
     const expressApp = express()
-    expressApp.get('/:image/:version/width-:width.:format', (req, res) => handleImageGet(req, res, {
-      ...req.params,
-      type: "width"
-    }))
-    expressApp.get('/:image/:version/width-:width', (req, res) => handleImageGet(req, res, {
-      ...req.params,
-      type: "width"
-    }))
-    expressApp.get('/:image/:version/height-:height.:format', (req, res) => handleImageGet(req, res, {
-      ...req.params,
-      type: "height"
-    }))
-    expressApp.get('/:image/:version/height-:height', (req, res) => handleImageGet(req, res, {
-      ...req.params,
-      type: "height"
-    }))
-    expressApp.get('/:image/:version/rect-:width-:height.:format', (req, res) => handleImageGet(req, res, {
-      ...req.params,
-      type: "rect"
-    }))
-    expressApp.get('/:image/:version/rect-:width-:height', (req, res) => handleImageGet(req, res, {
-      ...req.params,
-      type: "rect"
-    }))
-    expressApp.get('/:image/:version.:format', (req, res) => handleImageGet(req, res, {
-      ...req.params,
-      type: "auto"
-    }))
-    expressApp.get('/:image/:version', (req, res) => handleImageGet(req, res, {
-      ...req.params,
-      type: "auto"
-    }))
-    
+    expressApp.get('/:image/width-:width.:format',
+        (req, res) => handleImageGet(req, res, { ...req.params, type: "width" })
+    )
+    expressApp.get('/:image/width-:width',
+        (req, res) => handleImageGet(req, res, { ...req.params, type: "width" })
+    )
+    expressApp.get('/:image/height-:height.:format',
+        (req, res) => handleImageGet(req, res, { ...req.params, type: "height" })
+    )
+    expressApp.get('/:image/height-:height',
+        (req, res) => handleImageGet(req, res, { ...req.params, type: "height" })
+    )
+    expressApp.get('/:image/rect-:width-:height.:format',
+        (req, res) => handleImageGet(req, res, { ...req.params, type: "rect" })
+    )
+    expressApp.get('/:image/rect-:width-:height',
+        (req, res) => handleImageGet(req, res, { ...req.params, type: "rect" })
+    )
+    expressApp.get('/:image/.:format',
+        (req, res) => handleImageGet(req, res, { ...req.params, type: "original" })
+    )
+    expressApp.get('/:image',
+        (req, res) => handleImageGet(req, res, { ...req.params, type: "original" })
+    )
+    expressApp.use('*', async (req, res) => {
+      res.writeHead(200, { "Content-Type": "text/plain" })
+      res.end("IMAGE!")
+    })
     return expressApp
   }
 })

package/fsUtils.js

@@ -1,3 +1,4 @@
+const fs = require('fs')
 
 function move(from, to) {
   return new Promise((resolve,reject) => {

package/image.js

@@ -1,8 +1,22 @@
 const app = require("@live-change/framework").app()
 const definition = require('./definition.js')
+const config = definition.config
 
-const storageDir = `./storage/images/`
-const uploadsDir = `./uploads/`
+const imagesPath = config.imagesPath || `./storage/images/`
+const uploadsPath = config.uploadsPath || `./storage/uploads/`
+
+const cropInfo = {
+  type: Object,
+  properties: {
+    originalImage: {
+      type: String
+    },
+    x: { type: Number },
+    y: { type: Number },
+    zoom: { type: Number, defaultValue: 1 },
+    orientation: { type: Number }
+  }
+}
 
 const Image = definition.model({
   name: "Image",
@@ -15,145 +29,56 @@ const Image = definition.model({
     fileName: {
       type: String
     },
-    original: {
-      type: Object,
-      properties: {
-        width: { type: Number },
-        height: { type: Number },
-        extension: { type: String }
-      }
+    width: {
+      type: Number,
+      validation: ['nonEmpty']
     },
-    crop: {
-      type: Object,
-      properties: {
-        x: { type: Number },
-        y: { type: Number },
-        width: { type: Number },
-        height: { type: Number },
-        zoom: { type: Number, defaultValue: 1 },
-        orientation: {type: Number}
-      }
+    height: {
+      type: Number,
+      validation: ['nonEmpty']
+    },
+    extension: {
+      type: String,
+      validation: ['nonEmpty']
     },
     purpose: {
       type: String,
       validation: ['nonEmpty']
-    }
+    },
+    crop: cropInfo
   }
 })
 
 const { move, copy, mkdir, rmdir } = require('./fsUtils')
+const fs = require('fs')
 const sharp = require('sharp')
 const download = require('download')
 
-definition.action({
-  name: "createEmptyImage",
-  properties: {
-    name: {
-      type: String,
-      validation: ['nonEmpty']
-    },
-    purpose: {
-      type: String,
-      validation: ['nonEmpty']
-    },
-    ownerType: {
-      type: String,
-      validation: ['nonEmpty']
-    },
-    owner: {
-      type: String,
-      validation: ['nonEmpty']
-    }
-  },
-  /// TODO: accessControl
-  async execute({ name, purpose, owner, ownerType }, { client, service }, emit) {
-    const image = app.generateUid()
-
-    const dir = `${storageDir}${image}`
-
-    emit({
-      type: "ownerOwnedImageCreated",
-      image,
-      identifiers: {
-        owner, ownerType
-      },
-      data: {
-        name, purpose,
-        fileName: null,
-        original: null,
-        crop: null
-      }
-    })
-
-    await mkdir(dir)
-    await mkdir(`${dir}/originalCache`)
-    await mkdir(`${dir}/cropCache`)
+fs.mkdirSync(imagesPath, { recursive: true })
 
-    return image
-  }
-})
+const Upload = definition.foreignModel('upload', 'Upload')
 
 definition.action({
-  name: "uploadImage",
+  name: "createImage",
   properties: {
     image: {
       type: Image
     },
-    original: {
-      type: Object,
-      properties: {
-        width: { type: Number },
-        height: { type: Number },
-        uploadId: { type: String }
-      }
-    }
-  },
-  /// TODO: accessControl!
-  waitForEvents: true,
-  async execute({ image, original }, { client, service }, emit) {
-    const upload = await app.dao.get(['database', 'tableObject', app.databaseName, 'uploads', original.uploadId])
-    if(!upload) throw new Error("upload_not_found")
-    if(upload.state!='done') throw new Error("upload_not_done")
-
-    let extension = upload.fileName.match(/\.([A-Z0-9]+)$/i)[1].toLowerCase()
-    if(extension == 'jpg') extension = "jpeg"
-    const dir = `${storageDir}${image}`
-
-    emit({
-      type: "ownerOwnedImageUpdated",
-      image,
-      data: {
-        fileName: upload.fileName,
-        original: {
-          width: original.width,
-          height: original.height,
-          extension
-        },
-        crop: null
-      }
-    })
-
-    await move(`${uploadsDir}${upload.id}`, `${dir}/original.${extension}`)
-    await app.dao.request(['database', 'delete'], app.databaseName, 'uploads', upload.id)
-
-    return image
-  }
-})
-
-definition.action({
-  name: "createImage",
-  properties: {
     name: {
       type: String,
       validation: ['nonEmpty']
     },
-    original: {
-      type: Object,
-      properties: {
-        width: { type: Number },
-        height: { type: Number },
-        uploadId: { type: String }
-      }
+    width: {
+      type: Number,
+      validation: ['nonEmpty']
+    },
+    height: {
+      type: Number,
+      validation: ['nonEmpty']
+    },
+    upload: {
+      type: Upload,
+      validation: ['nonEmpty']
     },
     purpose: {
       type: String,
@@ -166,20 +91,26 @@ definition.action({
     owner: {
       type: String,
       validation: ['nonEmpty']
-    }
+    },
+    crop: cropInfo
   },
   /// TODO: accessControl!
   waitForEvents: true,
-  async execute({ name, original, purpose }, { client, service }, emit) {
-    const image = app.generateUid()
-    const upload = await app.dao.get(['database', 'tableObject', app.databaseName, 'uploads', original.uploadId])
-
-    if(!upload) throw new Error("upload_not_found")
-    if(upload.state!='done') throw new Error("upload_not_done")
+  async execute({ image, name, width, height, upload, purpose, owner, ownerType, crop }, { client, service }, emit) {
+    if(!image) {
+      image = app.generateUid()
+    } else {
+      // TODO: check id source session
+      const existing = await Image.get(image)
+      if (existing) throw 'already_exists'
+    }
+    const uploadRow = await Upload.get(upload)
+    if(!uploadRow) throw new Error("upload_not_found")
+    if(uploadRow.state!='done') throw new Error("upload_not_done")
 
-    let extension = upload.fileName.match(/\.([A-Z0-9]+)$/i)[1].toLowerCase()
+    let extension = uploadRow.fileName.match(/\.([A-Z0-9]+)$/i)[1].toLowerCase()
     if(extension == 'jpg') extension = "jpeg"
-    const dir = `${storageDir}${image}`
+    const dir = `${imagesPath}${image}`
 
     emit({
       type: "ownerOwnedImageCreated",
@@ -188,116 +119,21 @@ definition.action({
         owner, ownerType
       },
       data: {
-        name,
-        purpose,
-        fileName: upload.fileName,
-        original: {
-          width: original.width,
-          height: original.height,
-          extension
-        },
-        crop: null,
-        owner: client.user
+        name, purpose,
+        fileName: uploadRow.fileName,
+        width, height, extension, crop
       }
     })
 
     await mkdir(dir)
-    await mkdir(`${dir}/originalCache`)
-    await mkdir(`${dir}/cropCache`)
-    await move(`${uploadsDir}${upload.id}`, `${dir}/original.${extension}`)
-    await app.dao.request(['database', 'delete'], app.databaseName, 'uploads', upload.id)
-
-    return image
-  }
-})
-
-definition.action({
-  name: "cropImage",
-  properties: {
-    image: {
-      type: Image
-    },
-    crop: {
-      type: Object,
-      properties: {
-        x: {type: Number},
-        y: {type: Number},
-        width: {type: Number},
-        height: {type: Number},
-        zoom: {type: Number, defaultValue: 1},
-        orientation: {type: Number}
-      }
-    },
-    uploadId: {type: String}
-  },
-  /// TODO: accessControl!
-  waitForEvents: true,
-  async execute({ image, crop, uploadId }, {client, service}, emit) {
-    const imageRow = await Image.get(image)
-    if(!imageRow) throw new Error("not_found")
-
-    const upload = await app.dao.get(['database', 'tableObject', app.databaseName, 'uploads', uploadId])
-
-    console.log("UPLOAD CROP", upload)
-
-    if(!upload) throw new Error("upload_not_found")
-    if(upload.state != 'done') throw new Error("upload_not_done")
-
-    console.log("CURRENT IMAGE ROW", image, imageRow)
-    if(!imageRow.crop) { // first crop
-      const dir = `${storageDir}${image}`
-      let extension = upload.fileName.match(/\.([A-Z0-9]+)$/i)[1].toLowerCase()
-      if(extension == 'jpg') extension = "jpeg"
-
-      await move(`${uploadsDir}${upload.id}`, `${dir}/crop.${extension}`)
-      await app.dao.request(['database', 'delete'], app.databaseName, 'uploads', upload.id)
-
-      emit({
-        type: "ownerOwnedImageUpdated",
-        image,
-        data: {
-          crop
-        }
-      })
-
-      return image
-    } else { // next crop - need to copy image
-      const newImage = app.generateUid()
-
-      const dir = `${storageDir}${image}`
-      const newDir = `${storageDir}${newImage}`
+    await move(`${uploadsPath}${uploadRow.id}`, `${dir}/original.${extension}`)
 
-      await mkdir(newDir)
-      await mkdir(`${newDir}/originalCache`)
-      await mkdir(`${newDir}/cropCache`)
-      await move(`${dir}/original.${imageRow.original.extension}`,
-          `${newDir}/original.${imageRow.original.extension}`)
-
-      let extension = upload.fileName.match(/\.([A-Z0-9]+)$/i)[1].toLowerCase()
-      if(extension == 'jpg') extension = "jpeg"
-
-      await move(`../../storage/uploads/${upload.id}`, `${newDir}/crop.${extension}`)
-      await app.dao.request(['database', 'delete'], app.databaseName, 'uploads', upload.id)
-
-      const { owner, ownerType } = imageRow
-
-      emit({
-        type: "ownerOwnedImageCreated",
-        image,
-        identifiers: {
-          owner, ownerType
-        },
-        data: {
-          name: imageRow.name,
-          purpose: imageRow.purpose,
-          fileName: upload.fileName,
-          original: imageRow.original,
-          crop
-        }
-      })
+    await app.trigger({
+      type: 'uploadUsed',
+      upload: uploadRow.id
+    })
 
-      return newImage
-    }
+    return image
   }
 })
 
@@ -330,62 +166,53 @@ definition.trigger({
     }
   },
   waitForEvents: true,
-  async execute({ name, purpose, url, cropped, owner, ownerType }, { service, client }, emit) {
+  async execute({ name, purpose, url, owner, ownerType }, { service, client }, emit) {
     const image = app.generateUid()
 
-    const downloadPath = `${uploadsDir}download_${image}`
-    await download(url, uploadsDir, { filename: `download_${image}` })
+    const downloadPath = `${uploadsPath}download_${image}`
+    await download(url, uploadsPath, { filename: `download_${image}` })
 
     const metadata = await sharp(downloadPath).metadata()
 
-    let data = {
-      name,
-      purpose,
-      fileName: url.split('/').pop(),
-      original: {
-        width: metadata.width,
-        height: metadata.height,
-        extension: metadata.format
-      },
-      crop: null
-    }
-
-    if(cropped) {
-      data.crop = {
-        x: 0,
-        y: 0,
-        width: metadata.width,
-        height: metadata.height,
-        zoom: 1,
-        orientation: 0
-      }
-    }
-
-    emit({
-      type: "ImageCreated",
-      image,
-      data
-    })
-
     emit({
       type: "ownerOwnedImageCreated",
       image,
       identifiers: {
         owner, ownerType
       },
-      data
+      data: {
+        name, purpose,
+        fileName: url.split('/').pop(),
+        width: metadata.width,
+        height: metadata.height,
+        extension: metadata.format,
+        crop: null
+      }
     })
 
-    const dir = `${storageDir}/${image}`
+    const dir = `${imagesPath}/${image}`
 
     await mkdir(dir)
-    await mkdir(`${dir}/originalCache`)
-    await mkdir(`${dir}/cropCache`)
     await move(downloadPath, `${dir}/original.${metadata.format}`)
-    if(cropped) await copy(`${dir}/original.${metadata.format}`, `${dir}/crop.${metadata.format}`)
 
     return image
   }
 })
 
+definition.view({
+  name: 'image',
+  properties: {
+    image: {
+      type: Image,
+      validation: ['nonEmpty']
+    }
+  },
+  returns: {
+    type: Image
+  },
+  daoPath({ image }, { client, context }) {
+    return Image.path( image )
+  }
+})
+
 module.exports = { Image }

package/index.js

@@ -2,6 +2,8 @@ const app = require("@live-change/framework").app()
 
 const definition = require('./definition.js')
 
+require('./clientConfig.js')
 require('./image.js')
+require('./endpoint.js')
 
 module.exports = definition

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@live-change/image-service",
-  "version": "0.2.32",
+  "version": "0.2.35",
   "description": "",
   "main": "index.js",
   "scripts": {
@@ -21,9 +21,11 @@
     "url": "https://www.viamage.com/"
   },
   "dependencies": {
-    "@live-change/framework": "0.6.4",
-    "@live-change/relations-plugin": "0.6.3",
-    "pluralize": "8.0.0"
+    "@live-change/framework": "0.6.5",
+    "@live-change/relations-plugin": "0.6.5",
+    "download": "^8.0.0",
+    "pluralize": "8.0.0",
+    "sharp": "^0.30.6"
   },
-  "gitHead": "91f89af637893c2dbc0e1f55b2886345d408a9ea"
+  "gitHead": "f7b39211ab2b1de3fa579aab77ae208a8a1f9da3"
 }