@live-change/image-service 0.2.34 → 0.2.37

package/endpoint.js

@@ -32,11 +32,11 @@ function fileExists(fn) {
 function delay(ms) {
   return new Promise((resolve, reject) => setTimeout(resolve, ms))
 }
-async function getImageMetadata(picture, version) {
+async function getImageMetadata(image, version) {
   for(let t = 0; t < 5; t++) {
-    const metadata = await Image.get(picture)
+    const metadata = await Image.get(image)
     console.log("MD", metadata)
-    if(metadata.original && metadata[version]) return metadata
+    if(metadata) return metadata
     await delay(200 * Math.pow(2, t))
   }
   return null
@@ -47,32 +47,32 @@ function sanitizeImageId(id) {
 }
 
 async function handleImageGet(req, res, params) {
-  const { picture, version } = params
-  const metadata = await getImageMetadata(picture, version)
-  console.log("PIC METADATA", picture, version, "=>", metadata)
+  const { image } = params
+  const metadata = await getImageMetadata(image)
+  console.log("PIC METADATA", image, "=>", metadata)
   if(!metadata) {
     res.status(404)
-    res.send("Picture not found")
+    res.send("Image " + image + " not found")
     return
   }
-  const imagePrefix = imagesPath + sanitizeImageId(picture) + '/' + version.replace(/[^a-zA-Z0-9-]/g,"_")
-  const sourceFilePath = path.resolve(imagePrefix + '.' + metadata.original.extension)
-  console.log("SOURCE PIC PATH", sourceFilePath)
+  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("PICTURE FILE NOT FOUND", sourceFilePath)
-    res.send("Picture file not found")
+    console.error("IMAGE FILE NOT FOUND", sourceFilePath)
+    res.send("Image file not found")
     return
   }
 
   const kernel = "lanczos3"
 
   switch(params.type) {
-    case "auto": {
-      if(params.format && !isFormatsIdentical(params.format, metadata.original.extension)) {
-        console.log("CONVERTING PICTURE!", metadata.original.extension, params.format)
+    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 + '.' + normalized)
+        const convertedFilePath = path.resolve(imagePrefix + 'converted.' + normalized)
         if(!(await fileExists(convertedFilePath))) {
           await sharp(sourceFilePath).toFile(convertedFilePath)
         }
@@ -87,8 +87,8 @@ async function handleImageGet(req, res, params) {
         return
       }
       //if(width > metadata.original.width) return res.sendFile(sourceFilePath)
-      const normalized = normalizeFormat(params.format || metadata.original.extension)
-      const convertedFilePath = path.resolve(imagePrefix + `-width-${width}.${normalized}`)
+      const normalized = normalizeFormat(params.format || metadata.extension)
+      const convertedFilePath = path.resolve(imagePrefix + `width-${width}.${normalized}`)
       if(!(await fileExists(convertedFilePath))) {
         await sharp(sourceFilePath)
             .resize({
@@ -107,8 +107,8 @@ async function handleImageGet(req, res, params) {
         return
       }
       //if(height > metadata.original.height) return res.sendFile(sourceFilePath)
-      const normalized = normalizeFormat(params.format || metadata.original.extension)
-      const convertedFilePath = path.resolve(imagePrefix + `-height-${height}.${normalized}`)
+      const normalized = normalizeFormat(params.format || metadata.extension)
+      const convertedFilePath = path.resolve(imagePrefix + `height-${height}.${normalized}`)
       if(!(await fileExists(convertedFilePath))) {
         await sharp(sourceFilePath)
             .resize({
@@ -129,8 +129,8 @@ async function handleImageGet(req, res, params) {
       }
       //if(height > metadata.original.height) return res.sendFile(sourceFilePath)
       //if(width > metadata.original.width) return res.sendFile(sourceFilePath)
-      const normalized = normalizeFormat(params.format || metadata.original.extension)
-      const convertedFilePath = path.resolve(imagePrefix + `-rect-${width}-${height}.${normalized}`)
+      const normalized = normalizeFormat(params.format || metadata.extension)
+      const convertedFilePath = path.resolve(imagePrefix + `rect-${width}-${height}.${normalized}`)
       if(!(await fileExists(convertedFilePath))) {
         await sharp(sourceFilePath)
             .resize({
@@ -153,30 +153,34 @@ definition.endpoint({
   name: 'image',
   create() {
     const expressApp = express()
-    expressApp.get('/:image/:version/width-:width.:format',
+    expressApp.get('/:image/width-:width.:format',
         (req, res) => handleImageGet(req, res, { ...req.params, type: "width" })
     )
-    expressApp.get('/:image/:version/width-:width',
+    expressApp.get('/:image/width-:width',
         (req, res) => handleImageGet(req, res, { ...req.params, type: "width" })
     )
-    expressApp.get('/:image/:version/height-:height.:format',
+    expressApp.get('/:image/height-:height.:format',
         (req, res) => handleImageGet(req, res, { ...req.params, type: "height" })
     )
-    expressApp.get('/:image/:version/height-:height',
+    expressApp.get('/:image/height-:height',
         (req, res) => handleImageGet(req, res, { ...req.params, type: "height" })
     )
-    expressApp.get('/:image/:version/rect-:width-:height.:format',
+    expressApp.get('/:image/rect-:width-:height.:format',
         (req, res) => handleImageGet(req, res, { ...req.params, type: "rect" })
     )
-    expressApp.get('/:image/:version/rect-:width-:height',
+    expressApp.get('/:image/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/.:format',
+        (req, res) => handleImageGet(req, res, { ...req.params, type: "original" })
     )
-    expressApp.get('/:image/:version',
-        (req, res) => handleImageGet(req, res, { ...req.params, type: "auto" })
+    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/image.js

@@ -5,6 +5,19 @@ const config = definition.config
 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",
   itemOfAny: {
@@ -16,144 +29,34 @@ const Image = definition.model({
     fileName: {
       type: String
     },
-    original: {
-      type: Object,
-      properties: {
-        width: { type: Number },
-        height: { type: Number },
-        extension: { type: String }
-      }
-    },
-    crop: {
-      type: Object,
-      properties: {
-        x: { type: Number },
-        y: { type: Number },
-        width: { type: Number },
-        height: { type: Number },
-        zoom: { type: Number, defaultValue: 1 },
-        orientation: {type: Number}
-      }
-    },
-    purpose: {
-      type: String,
+    width: {
+      type: Number,
       validation: ['nonEmpty']
-    }
-  }
-})
-
-const { move, copy, mkdir, rmdir } = require('./fsUtils')
-const sharp = require('sharp')
-const download = require('download')
-
-definition.action({
-  name: "createEmptyImage",
-  properties: {
-    image: {
-      type: Image
     },
-    name: {
-      type: String,
+    height: {
+      type: Number,
       validation: ['nonEmpty']
     },
-    purpose: {
+    extension: {
       type: String,
       validation: ['nonEmpty']
     },
-    ownerType: {
+    purpose: {
       type: String,
       validation: ['nonEmpty']
     },
-    owner: {
-      type: String,
-      validation: ['nonEmpty']
-    }
-  },
-  /// TODO: accessControl
-  async execute({ image, name, purpose, owner, ownerType }, { 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 dir = `${imagesPath}${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`)
-
-    return image
+    crop: cropInfo
   }
 })
 
-const Upload = definition.foreignModel('upload', 'Upload')
-
-definition.action({
-  name: "uploadImage",
-  properties: {
-    image: {
-      type: Image
-    },
-    original: {
-      type: Object,
-      properties: {
-        width: { type: Number },
-        height: { type: Number },
-        upload: { type: Upload }
-      }
-    }
-  },
-  /// TODO: accessControl!
-  waitForEvents: true,
-  async execute({ image, original }, { client, service }, emit) {
-    const uploadRow = await Upload.get(original.upload)
-    if(!uploadRow) throw new Error("upload_not_found")
-    if(uploadRow.state!='done') throw new Error("upload_not_done")
-
-    let extension = uploadRow.fileName.match(/\.([A-Z0-9]+)$/i)[1].toLowerCase()
-    if(extension == 'jpg') extension = "jpeg"
-    const dir = `${imagesPath}${image}`
-
-    emit({
-      type: "ownerOwnedImageUpdated",
-      image,
-      data: {
-        fileName: uploadRow.fileName,
-        original: {
-          width: original.width,
-          height: original.height,
-          extension
-        },
-        crop: null
-      }
-    })
+const { move, copy, mkdir, rmdir } = require('./fsUtils')
+const fs = require('fs')
+const sharp = require('sharp')
+const download = require('download')
 
-    await move(`${uploadsPath}${uploadRow.id}`, `${dir}/original.${extension}`)
-    await app.trigger({
-      type: 'uploadUsed',
-      upload: uploadRow.id
-    })
+fs.mkdirSync(imagesPath, { recursive: true })
 
-    return image
-  }
-})
+const Upload = definition.foreignModel('upload', 'Upload')
 
 definition.action({
   name: "createImage",
@@ -165,13 +68,17 @@ definition.action({
       type: String,
       validation: ['nonEmpty']
     },
-    original: {
-      type: Object,
-      properties: {
-        width: { type: Number },
-        height: { type: Number },
-        upload: { type: Upload }
-      }
+    width: {
+      type: Number,
+      validation: ['nonEmpty']
+    },
+    height: {
+      type: Number,
+      validation: ['nonEmpty']
+    },
+    upload: {
+      type: Upload,
+      validation: ['nonEmpty']
     },
     purpose: {
       type: String,
@@ -184,11 +91,12 @@ definition.action({
     owner: {
       type: String,
       validation: ['nonEmpty']
-    }
+    },
+    crop: cropInfo
   },
   /// TODO: accessControl!
   waitForEvents: true,
-  async execute({ image, name, original, purpose, owner, ownerType }, { client, service }, emit) {
+  async execute({ image, name, width, height, upload, purpose, owner, ownerType, crop }, { client, service }, emit) {
     if(!image) {
       image = app.generateUid()
     } else {
@@ -196,7 +104,7 @@ definition.action({
       const existing = await Image.get(image)
       if (existing) throw 'already_exists'
     }
-    const uploadRow = await Upload.get(original.upload)
+    const uploadRow = await Upload.get(upload)
     if(!uploadRow) throw new Error("upload_not_found")
     if(uploadRow.state!='done') throw new Error("upload_not_done")
 
@@ -211,22 +119,13 @@ definition.action({
         owner, ownerType
       },
       data: {
-        name,
-        purpose,
+        name, purpose,
         fileName: uploadRow.fileName,
-        original: {
-          width: original.width,
-          height: original.height,
-          extension
-        },
-        crop: null,
-        owner: client.user
+        width, height, extension, crop
       }
     })
 
     await mkdir(dir)
-    await mkdir(`${dir}/originalCache`)
-    await mkdir(`${dir}/cropCache`)
     await move(`${uploadsPath}${uploadRow.id}`, `${dir}/original.${extension}`)
 
     await app.trigger({
@@ -238,100 +137,6 @@ definition.action({
   }
 })
 
-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}
-      }
-    },
-    upload: {type: Upload}
-  },
-  /// TODO: accessControl!
-  waitForEvents: true,
-  async execute({ image, crop, upload }, {client, service}, emit) {
-    const imageRow = await Image.get(image)
-    if(!imageRow) throw new Error("not_found")
-
-    const uploadRow = await Upload.get(upload)
-
-    console.log("UPLOAD CROP", uploadRow)
-
-    if(!uploadRow) throw new Error("upload_not_found")
-    if(uploadRow.state != 'done') throw new Error("upload_not_done")
-
-    console.log("CURRENT IMAGE ROW", image, imageRow)
-    if(!imageRow.crop) { // first crop
-      const dir = `${imagesPath}${image}`
-      let extension = uploadRow.fileName.match(/\.([A-Z0-9]+)$/i)[1].toLowerCase()
-      if(extension == 'jpg') extension = "jpeg"
-
-      await move(`${uploadsPath}${uploadRow.id}`, `${dir}/crop.${extension}`)
-      await app.dao.request(['database', 'delete'], app.databaseName, 'uploads', uploadRow.id)
-
-      emit({
-        type: "ownerOwnedImageUpdated",
-        image,
-        data: {
-          crop
-        }
-      })
-
-      return image
-    } else { // next crop - need to copy image
-      const newImage = app.generateUid()
-
-      const dir = `${imagesPath}${image}`
-      const newDir = `${imagesPath}${newImage}`
-
-      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 = uploadRow.fileName.match(/\.([A-Z0-9]+)$/i)[1].toLowerCase()
-      if(extension == 'jpg') extension = "jpeg"
-
-      await move(`../../storage/uploads/${uploadRow.id}`, `${newDir}/crop.${extension}`)
-
-      await app.trigger({
-        type: 'uploadUsed',
-        upload: uploadRow.id
-      })
-
-      const { owner, ownerType } = imageRow
-
-      emit({
-        type: "ownerOwnedImageCreated",
-        image,
-        identifiers: {
-          owner, ownerType
-        },
-        data: {
-          name: imageRow.name,
-          purpose: imageRow.purpose,
-          fileName: uploadRow.fileName,
-          original: imageRow.original,
-          crop
-        }
-      })
-
-      return newImage
-    }
-  }
-})
-
 definition.trigger({
   name: "createImageFromUrl",
   properties: {
@@ -361,7 +166,7 @@ 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 = `${uploadsPath}download_${image}`
@@ -369,54 +174,45 @@ definition.trigger({
 
     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 = `${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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@live-change/image-service",
-  "version": "0.2.34",
+  "version": "0.2.37",
   "description": "",
   "main": "index.js",
   "scripts": {
@@ -27,5 +27,5 @@
     "pluralize": "8.0.0",
     "sharp": "^0.30.6"
   },
-  "gitHead": "45f52d6c7586d0eaa51b3205c6635a33e32eef6b"
+  "gitHead": "f3bc615d20a0112c7cc76d55ba1cbefb53b84f01"
 }