@jsreport/jsreport-core 3.0.1 → 3.1.2-test.2

package/lib/main/store/setupValidateShortid.js

@@ -1,71 +1,71 @@
-const omit = require('lodash.omit')
-
-module.exports = (reporter) => {
-  reporter.initializeListeners.add('core-validate-shortid', () => {
-    for (const c of Object.keys(reporter.documentStore.collections)) {
-      const es = reporter.documentStore.model.entitySets[c]
-      const et = reporter.documentStore.model.entityTypes[es.entityType.substring('jsreport.'.length)]
-
-      if (!et.shortid) {
-        return
-      }
-
-      reporter.documentStore.collection(c).beforeInsertListeners.add('validate-shortid', (doc, req) => {
-        return validateShortid(reporter, c, doc, undefined, req)
-      })
-
-      reporter.documentStore.collection(c).beforeUpdateListeners.add('validate-shortid', async (q, update, opts, req) => {
-        if (update.$set && opts && opts.upsert === true) {
-          await validateShortid(reporter, c, update.$set, undefined, req)
-        }
-
-        if (typeof update.$set.shortid === 'undefined') {
-          return
-        }
-
-        const entitiesToUpdate = await reporter.documentStore.collection(c).find(q, req)
-        return Promise.all(entitiesToUpdate.map(e => validateShortid(reporter, c, Object.assign({}, e, update.$set), e._id, req)))
-      })
-    }
-  })
-}
-
-async function validateShortid (reporter, collectionName, doc, originalIdValue, req) {
-  const shortid = doc.shortid
-
-  if (!shortid) {
-    throw reporter.createError('Entity shortid property can not be empty', {
-      statusCode: 400
-    })
-  }
-
-  const existingEntity = await findEntity(reporter, collectionName, shortid, req)
-
-  if (existingEntity) {
-    if (originalIdValue != null && existingEntity._id === originalIdValue) {
-      return
-    }
-
-    throw reporter.createError(`Entity with shortid "${shortid}" already exists.`, {
-      statusCode: 400,
-      code: 'DUPLICATED_ENTITY',
-      existingEntity,
-      existingEntityEntitySet: collectionName
-    })
-  }
-}
-
-async function findEntity (reporter, collectionName, shortid, req) {
-  const localReq = req ? reporter.Request(req) : req
-
-  // we should validate without caring about permissions
-  if (localReq) {
-    localReq.context = localReq.context ? omit(localReq.context, 'user') : localReq.context
-  }
-
-  const existingEntity = await reporter.documentStore.collection(collectionName).findOne({
-    shortid
-  }, localReq)
-
-  return existingEntity
-}
+const omit = require('lodash.omit')
+
+module.exports = (reporter) => {
+  reporter.initializeListeners.add('core-validate-shortid', () => {
+    for (const c of Object.keys(reporter.documentStore.collections)) {
+      const es = reporter.documentStore.model.entitySets[c]
+      const et = reporter.documentStore.model.entityTypes[es.entityType.substring('jsreport.'.length)]
+
+      if (!et.shortid) {
+        return
+      }
+
+      reporter.documentStore.collection(c).beforeInsertListeners.add('validate-shortid', (doc, req) => {
+        return validateShortid(reporter, c, doc, undefined, req)
+      })
+
+      reporter.documentStore.collection(c).beforeUpdateListeners.add('validate-shortid', async (q, update, opts, req) => {
+        if (update.$set && opts && opts.upsert === true) {
+          await validateShortid(reporter, c, update.$set, undefined, req)
+        }
+
+        if (typeof update.$set.shortid === 'undefined') {
+          return
+        }
+
+        const entitiesToUpdate = await reporter.documentStore.collection(c).find(q, req)
+        return Promise.all(entitiesToUpdate.map(e => validateShortid(reporter, c, Object.assign({}, e, update.$set), e._id, req)))
+      })
+    }
+  })
+}
+
+async function validateShortid (reporter, collectionName, doc, originalIdValue, req) {
+  const shortid = doc.shortid
+
+  if (!shortid) {
+    throw reporter.createError('Entity shortid property can not be empty', {
+      statusCode: 400
+    })
+  }
+
+  const existingEntity = await findEntity(reporter, collectionName, shortid, req)
+
+  if (existingEntity) {
+    if (originalIdValue != null && existingEntity._id === originalIdValue) {
+      return
+    }
+
+    throw reporter.createError(`Entity with shortid "${shortid}" already exists.`, {
+      statusCode: 400,
+      code: 'DUPLICATED_ENTITY',
+      existingEntity,
+      existingEntityEntitySet: collectionName
+    })
+  }
+}
+
+async function findEntity (reporter, collectionName, shortid, req) {
+  const localReq = req ? reporter.Request(req) : req
+
+  // we should validate without caring about permissions
+  if (localReq) {
+    localReq.context = localReq.context ? omit(localReq.context, 'user') : localReq.context
+  }
+
+  const existingEntity = await reporter.documentStore.collection(collectionName).findOne({
+    shortid
+  }, localReq)
+
+  return existingEntity
+}

package/lib/main/store/transaction.js

@@ -1,69 +1,69 @@
-const extend = require('node.extend.without.arrays')
-
-module.exports = ({ queue }) => {
-  let commitedDocuments = {}
-
-  return {
-    getCurrentDocuments (opts = {}) {
-      return opts.transaction == null ? commitedDocuments : opts.transaction.documents
-    },
-
-    begin () {
-      return queue.push(async () => {
-        return {
-          documents: cloneDocuments(commitedDocuments),
-          operations: [],
-          beginTime: Date.now()
-        }
-      })
-    },
-
-    async operation (opts, fn) {
-      if (fn == null) {
-        fn = opts
-      }
-
-      if (opts.transaction) {
-        return queue.push(() => {
-          opts.transaction.operations.push(fn)
-          return fn(opts.transaction.documents)
-        })
-      }
-
-      return queue.push(() => fn(commitedDocuments))
-    },
-
-    async commit (transaction) {
-      return queue.push(async () => {
-        const documentsClone = cloneDocuments(commitedDocuments)
-
-        for (const op of transaction.operations) {
-          await op(documentsClone)
-        }
-
-        for (const entitySet in documentsClone) {
-          for (const transactionEntity of documentsClone[entitySet]) {
-            const commitedEntity = commitedDocuments[entitySet].find(e => e._id)
-            if (commitedEntity &&
-              transactionEntity.$$etag !== commitedEntity.$$etag &&
-              commitedEntity.$$etag > transaction.beginTime
-            ) {
-              throw new Error(`Entity ${transactionEntity.name} was modified by another transaction`)
-            }
-          }
-        }
-
-        commitedDocuments = documentsClone
-      })
-    },
-
-    async rollback (transaction) {}
-  }
-}
-
-function cloneDocuments (obj) {
-  return Object.keys(obj).reduce((acu, setName) => {
-    acu[setName] = obj[setName].map((doc) => extend(true, {}, doc))
-    return acu
-  }, {})
-}
+const extend = require('node.extend.without.arrays')
+
+module.exports = ({ queue }) => {
+  let commitedDocuments = {}
+
+  return {
+    getCurrentDocuments (opts = {}) {
+      return opts.transaction == null ? commitedDocuments : opts.transaction.documents
+    },
+
+    begin () {
+      return queue.push(async () => {
+        return {
+          documents: cloneDocuments(commitedDocuments),
+          operations: [],
+          beginTime: Date.now()
+        }
+      })
+    },
+
+    async operation (opts, fn) {
+      if (fn == null) {
+        fn = opts
+      }
+
+      if (opts.transaction) {
+        return queue.push(() => {
+          opts.transaction.operations.push(fn)
+          return fn(opts.transaction.documents)
+        })
+      }
+
+      return queue.push(() => fn(commitedDocuments))
+    },
+
+    async commit (transaction) {
+      return queue.push(async () => {
+        const documentsClone = cloneDocuments(commitedDocuments)
+
+        for (const op of transaction.operations) {
+          await op(documentsClone)
+        }
+
+        for (const entitySet in documentsClone) {
+          for (const transactionEntity of documentsClone[entitySet]) {
+            const commitedEntity = commitedDocuments[entitySet].find(e => e._id)
+            if (commitedEntity &&
+              transactionEntity.$$etag !== commitedEntity.$$etag &&
+              commitedEntity.$$etag > transaction.beginTime
+            ) {
+              throw new Error(`Entity ${transactionEntity.name} was modified by another transaction`)
+            }
+          }
+        }
+
+        commitedDocuments = documentsClone
+      })
+    },
+
+    async rollback (transaction) {}
+  }
+}
+
+function cloneDocuments (obj) {
+  return Object.keys(obj).reduce((acu, setName) => {
+    acu[setName] = obj[setName].map((doc) => extend(true, {}, doc))
+    return acu
+  }, {})
+}

package/lib/main/store/typeUtils.js

@@ -1,180 +1,180 @@
-
-function getType (model, container, typeName, returnNormalizedTypeName) {
-  const normalizedTypeName = typeName.replace(model.namespace + '.', '')
-  const typeInfo = container[normalizedTypeName]
-
-  if (!typeInfo) {
-    return
-  }
-
-  if (returnNormalizedTypeName === true) {
-    return normalizedTypeName
-  }
-
-  return typeInfo
-}
-
-function resolvePropDefinition (model, def) {
-  const result = {}
-  const collectionTypeRegExp = /^Collection\((\S+)\)$/
-  const collectionMatchResult = collectionTypeRegExp.exec(def.type)
-
-  if (def.type.startsWith('Edm')) {
-    result.def = def
-  } else if (collectionMatchResult != null && collectionMatchResult[1] != null) {
-    const childType = collectionMatchResult[1]
-
-    if (childType.startsWith('Edm')) {
-      result.def = def
-      result.subDef = { type: childType }
-    } else {
-      const subType = getType(model, model.complexTypes, childType)
-
-      if (subType != null) {
-        result.def = def
-        result.subType = subType
-      }
-    }
-  } else {
-    const subType = getType(model, model.complexTypes, def.type)
-
-    if (subType) {
-      result.def = def
-      result.subType = subType
-    }
-  }
-
-  if (Object.keys(result).length === 0) {
-    return
-  }
-
-  return result
-}
-
-const edmTypeToJSONSchema = {
-  'Edm.String': 'string',
-  'Edm.DateTimeOffset': { anyOf: [{ '$jsreport-stringToDate': true }, { '$jsreport-acceptsDate': true }] },
-  'Edm.Boolean': 'boolean',
-  'Edm.Int16': { type: 'integer', minimum: -32768, maximum: 32767 },
-  'Edm.Int32': { type: 'integer', minimum: -2147483648, maximum: 2147483647 },
-  'Edm.Double': 'number',
-  'Edm.Decimal': 'number',
-  'Edm.Binary': { anyOf: [{ type: 'null' }, { type: 'string' }, { '$jsreport-acceptsBuffer': true }] }
-}
-
-function typeDefToJSONSchema (model, def) {
-  const jsonSchema = { type: 'object', properties: {} }
-
-  if (def == null) {
-    return
-  }
-
-  if (typeof def !== 'object' || Array.isArray(def)) {
-    return
-  }
-
-  Object.keys(def).forEach((key) => {
-    const propDef = def[key]
-
-    if (propDef == null || propDef.type == null) {
-      return
-    }
-
-    const extraSchema = propDef.schema
-
-    const resolveResult = resolvePropDefinition(model, propDef)
-
-    if (!resolveResult) {
-      return
-    }
-
-    const isCollection = resolveResult.def.type.startsWith('Collection(')
-
-    if (resolveResult.subType) {
-      jsonSchema.properties[key] = typeDefToJSONSchema(model, resolveResult.subType)
-    } else if (
-      (isCollection && resolveResult.subType == null) ||
-      (resolveResult.def.type.startsWith('Edm') && edmTypeToJSONSchema[resolveResult.def.type] != null)
-    ) {
-      let targetType = resolveResult.def.type
-
-      if (isCollection && resolveResult.subType == null) {
-        targetType = resolveResult.subDef.type
-      }
-
-      const value = edmTypeToJSONSchema[targetType]
-
-      if (typeof value === 'string') {
-        jsonSchema.properties[key] = { type: value }
-      } else {
-        jsonSchema.properties[key] = value
-      }
-    }
-
-    if (isCollection) {
-      jsonSchema.properties[key] = {
-        type: 'array',
-        items: jsonSchema.properties[key]
-      }
-    }
-
-    if (extraSchema) {
-      let originalType = jsonSchema.properties[key].type
-      let newType = extraSchema.type
-
-      if (originalType != null && newType != null) {
-        if (!Array.isArray(originalType)) {
-          originalType = [jsonSchema.properties[key].type]
-        }
-
-        if (!Array.isArray(newType)) {
-          newType = [newType]
-        }
-
-        jsonSchema.properties[key] = {
-          ...jsonSchema.properties[key],
-          ...extraSchema,
-          type: [...originalType, ...newType]
-        }
-      } else if (newType != null && originalType == null) {
-        let newProperties = {}
-
-        if (Array.isArray(jsonSchema.properties[key].anyOf)) {
-          newProperties = {
-            anyOf: [...jsonSchema.properties[key].anyOf, { type: newType }]
-          }
-        } else if (Array.isArray(jsonSchema.properties[key].allOf)) {
-          newProperties = {
-            allOf: [...jsonSchema.properties[key].allOf, { type: newType }]
-          }
-        } else if (Array.isArray(jsonSchema.properties[key].oneOf)) {
-          newProperties = {
-            oneOf: [...jsonSchema.properties[key].oneOf, { type: newType }]
-          }
-        }
-
-        const copyExtraSchema = { ...extraSchema }
-
-        delete copyExtraSchema.type
-
-        jsonSchema.properties[key] = {
-          ...jsonSchema.properties[key],
-          ...copyExtraSchema,
-          ...newProperties
-        }
-      } else {
-        jsonSchema.properties[key] = Object.assign({}, jsonSchema.properties[key], extraSchema)
-      }
-    }
-  })
-
-  if (Object.keys(jsonSchema.properties).length === 0) {
-    return
-  }
-
-  return jsonSchema
-}
-
-module.exports.getType = getType
-module.exports.resolvePropDefinition = resolvePropDefinition
-module.exports.typeDefToJSONSchema = typeDefToJSONSchema
+
+function getType (model, container, typeName, returnNormalizedTypeName) {
+  const normalizedTypeName = typeName.replace(model.namespace + '.', '')
+  const typeInfo = container[normalizedTypeName]
+
+  if (!typeInfo) {
+    return
+  }
+
+  if (returnNormalizedTypeName === true) {
+    return normalizedTypeName
+  }
+
+  return typeInfo
+}
+
+function resolvePropDefinition (model, def) {
+  const result = {}
+  const collectionTypeRegExp = /^Collection\((\S+)\)$/
+  const collectionMatchResult = collectionTypeRegExp.exec(def.type)
+
+  if (def.type.startsWith('Edm')) {
+    result.def = def
+  } else if (collectionMatchResult != null && collectionMatchResult[1] != null) {
+    const childType = collectionMatchResult[1]
+
+    if (childType.startsWith('Edm')) {
+      result.def = def
+      result.subDef = { type: childType }
+    } else {
+      const subType = getType(model, model.complexTypes, childType)
+
+      if (subType != null) {
+        result.def = def
+        result.subType = subType
+      }
+    }
+  } else {
+    const subType = getType(model, model.complexTypes, def.type)
+
+    if (subType) {
+      result.def = def
+      result.subType = subType
+    }
+  }
+
+  if (Object.keys(result).length === 0) {
+    return
+  }
+
+  return result
+}
+
+const edmTypeToJSONSchema = {
+  'Edm.String': 'string',
+  'Edm.DateTimeOffset': { anyOf: [{ '$jsreport-stringToDate': true }, { '$jsreport-acceptsDate': true }] },
+  'Edm.Boolean': 'boolean',
+  'Edm.Int16': { type: 'integer', minimum: -32768, maximum: 32767 },
+  'Edm.Int32': { type: 'integer', minimum: -2147483648, maximum: 2147483647 },
+  'Edm.Double': 'number',
+  'Edm.Decimal': 'number',
+  'Edm.Binary': { anyOf: [{ type: 'null' }, { type: 'string' }, { '$jsreport-acceptsBuffer': true }] }
+}
+
+function typeDefToJSONSchema (model, def) {
+  const jsonSchema = { type: 'object', properties: {} }
+
+  if (def == null) {
+    return
+  }
+
+  if (typeof def !== 'object' || Array.isArray(def)) {
+    return
+  }
+
+  Object.keys(def).forEach((key) => {
+    const propDef = def[key]
+
+    if (propDef == null || propDef.type == null) {
+      return
+    }
+
+    const extraSchema = propDef.schema
+
+    const resolveResult = resolvePropDefinition(model, propDef)
+
+    if (!resolveResult) {
+      return
+    }
+
+    const isCollection = resolveResult.def.type.startsWith('Collection(')
+
+    if (resolveResult.subType) {
+      jsonSchema.properties[key] = typeDefToJSONSchema(model, resolveResult.subType)
+    } else if (
+      (isCollection && resolveResult.subType == null) ||
+      (resolveResult.def.type.startsWith('Edm') && edmTypeToJSONSchema[resolveResult.def.type] != null)
+    ) {
+      let targetType = resolveResult.def.type
+
+      if (isCollection && resolveResult.subType == null) {
+        targetType = resolveResult.subDef.type
+      }
+
+      const value = edmTypeToJSONSchema[targetType]
+
+      if (typeof value === 'string') {
+        jsonSchema.properties[key] = { type: value }
+      } else {
+        jsonSchema.properties[key] = value
+      }
+    }
+
+    if (isCollection) {
+      jsonSchema.properties[key] = {
+        type: 'array',
+        items: jsonSchema.properties[key]
+      }
+    }
+
+    if (extraSchema) {
+      let originalType = jsonSchema.properties[key].type
+      let newType = extraSchema.type
+
+      if (originalType != null && newType != null) {
+        if (!Array.isArray(originalType)) {
+          originalType = [jsonSchema.properties[key].type]
+        }
+
+        if (!Array.isArray(newType)) {
+          newType = [newType]
+        }
+
+        jsonSchema.properties[key] = {
+          ...jsonSchema.properties[key],
+          ...extraSchema,
+          type: [...originalType, ...newType]
+        }
+      } else if (newType != null && originalType == null) {
+        let newProperties = {}
+
+        if (Array.isArray(jsonSchema.properties[key].anyOf)) {
+          newProperties = {
+            anyOf: [...jsonSchema.properties[key].anyOf, { type: newType }]
+          }
+        } else if (Array.isArray(jsonSchema.properties[key].allOf)) {
+          newProperties = {
+            allOf: [...jsonSchema.properties[key].allOf, { type: newType }]
+          }
+        } else if (Array.isArray(jsonSchema.properties[key].oneOf)) {
+          newProperties = {
+            oneOf: [...jsonSchema.properties[key].oneOf, { type: newType }]
+          }
+        }
+
+        const copyExtraSchema = { ...extraSchema }
+
+        delete copyExtraSchema.type
+
+        jsonSchema.properties[key] = {
+          ...jsonSchema.properties[key],
+          ...copyExtraSchema,
+          ...newProperties
+        }
+      } else {
+        jsonSchema.properties[key] = Object.assign({}, jsonSchema.properties[key], extraSchema)
+      }
+    }
+  })
+
+  if (Object.keys(jsonSchema.properties).length === 0) {
+    return
+  }
+
+  return jsonSchema
+}
+
+module.exports.getType = getType
+module.exports.resolvePropDefinition = resolvePropDefinition
+module.exports.typeDefToJSONSchema = typeDefToJSONSchema