10511826445

Committed 22 Aug 2024 04:16PM UTC coverage: 97.329% (+0.02%) from 97.313%

Build # 10511826445

Build Type

push

github

Committed by

danibix95

Commit Message

refactor: enforce quoting strings in CSV export

Run Details

1418 of 1522 branches covered (93.17%)

Branch coverage included in aggregate %.

1 of 1 new or added line in 1 file covered. (100.0%)

3 existing lines in 1 file now uncovered.

9077 of 9261 relevant lines covered (98.01%)

7821.3 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

95.36

/lib/createIndexes.js

/*
 * Copyright 2023 Mia s.r.l.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

'use strict'

const { MONGOID, HASHED_FIELD, GEO_FIELD, TEXT_FIELD, NORMAL_INDEX, HASHED_INDEX, GEO_INDEX, TEXT_INDEX } = require('./consts')

const addKeyToSpec = (specObject, { name, order }) => ({ ...specObject, [name]: order })
const addTextKeyToSpec = (specObject, { name }) => ({ ...specObject, [name]: TEXT_FIELD })

module.exports = async function createIndexes(collection, indexes, prefixOfIndexesToPreserve) {
  let alreadyPresentIndexes = []
  const indexNamesToMantain = []
  const indexNamesToDrop = []
  try {
    alreadyPresentIndexes = await collection.indexes()
  } catch (error) {
    // throws if the collection doesn't exists...
  }

  const indexesNames = indexes.map(index => (index['name']))

  alreadyPresentIndexes.forEach(foundIndex => {
    if (
      !foundIndex.name.startsWith(prefixOfIndexesToPreserve)
      && !foundIndex.key._id
      && !(
        indexesNames.includes(foundIndex.name)
        && checkIndexEquality(foundIndex, indexes.find(idx => idx.name === foundIndex.name))
      )
    ) {
      indexNamesToDrop.push(foundIndex.name)
    } else {
      indexNamesToMantain.push(foundIndex.name)
    }
  })

  await Promise.allSettled(indexNamesToDrop.map(name => collection.dropIndex(name)))

  return Promise.allSettled(indexes
    .filter(index => index.name !== MONGOID && !indexNamesToMantain.includes(index.name))
    .map(index => createIndex(collection, index)))
}

async function createIndex(collection, index) {
  let spec

  switch (index.type) {
  case NORMAL_INDEX: {
    spec = index.fields.reduce(addKeyToSpec, {})
    break
  }
  case GEO_INDEX: {
    const { field } = index
    spec = { [field]: GEO_FIELD }
    break
  }
  case HASHED_INDEX: {
    const { field } = index
    spec = { [field]: HASHED_FIELD }
    break
  }
  case TEXT_INDEX: {
    spec = index.fields.reduce(addTextKeyToSpec, {})
    break
  }
  default: {
    throw new Error(`Cannot create index of type ${index?.type}`)
  }
  }

  const options = getIndexOptions(index)
  return collection.createIndex(spec, options)
}

function getIndexOptions(index) {
  let options = {
    name: index.name,
    unique: index.unique || false,
    background: true,
  }

  if (index.expireAfterSeconds) {
    options = { ...options, expireAfterSeconds: index.expireAfterSeconds }
  }
  if (index.weights) {
    options = { ...options, weights: index.weights }
  }
  if (index.defaultLanguage) {
    options = { ...options, default_language: index.defaultLanguage }
  }
  if (index.languageOverride) {
    options = { ...options, language_override: index.languageOverride }
  }
  if (index.usePartialFilter) {
    let partialFilterExpression
    try {
      partialFilterExpression = index.partialFilterExpression ? JSON.parse(index.partialFilterExpression) : {}
    } catch (error) {
      throw new Error(`Impossible to parse the Partial Index expression of index ${index.name}`, { catch: error })
    }

    options = { ...options, partialFilterExpression }
  }
  return options
}

function checkIndexEquality(foundIndex, index) {
  const isOptionUniqueEqual = index.unique ? foundIndex.unique === true : foundIndex.unique === undefined
  const isOptionExpireAfterSecondsEqual = foundIndex.expireAfterSeconds === index.expireAfterSeconds
  return (
    isOptionUniqueEqual
    && isOptionExpireAfterSecondsEqual
    && checkIndexEqualityByType(foundIndex, index)
  )
}

function checkIndexEqualityByType(foundIndex, index) {
  switch (index.type) {
  case NORMAL_INDEX: {
    const expectedKey = index.fields.reduce(addKeyToSpec, {})
    return JSON.stringify(foundIndex.key) === JSON.stringify(expectedKey)
  }
  case GEO_INDEX: {
    return foundIndex.key[index.field] === GEO_FIELD
  }
  case HASHED_INDEX: {
    return foundIndex.key[index.field] === HASHED_FIELD
  }
  case TEXT_INDEX: {
    const expectedKey = index.fields.reduce(addTextKeyToSpec, {})
    return JSON.stringify(foundIndex.key) === JSON.stringify(expectedKey)
  }
  default:
    return false
  }
}

1	/*	99✔
2	* Copyright 2023 Mia s.r.l.	99✔
3	*	99✔
4	* Licensed under the Apache License, Version 2.0 (the "License");	99✔
5	* you may not use this file except in compliance with the License.	99✔
6	* You may obtain a copy of the License at	99✔
7	*	99✔
8	* http://www.apache.org/licenses/LICENSE-2.0	99✔
9	*	99✔
10	* Unless required by applicable law or agreed to in writing, software	99✔
11	* distributed under the License is distributed on an "AS IS" BASIS,	99✔
12	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.	99✔
13	* See the License for the specific language governing permissions and	99✔
14	* limitations under the License.	99✔
15	*/	99✔
16		99✔
17	'use strict'	99✔
18		99✔
19	const { MONGOID, HASHED_FIELD, GEO_FIELD, TEXT_FIELD, NORMAL_INDEX, HASHED_INDEX, GEO_INDEX, TEXT_INDEX } = require('./consts')	99✔
20		99✔
21	const addKeyToSpec = (specObject, { name, order }) => ({ ...specObject, [name]: order })	99✔
22	const addTextKeyToSpec = (specObject, { name }) => ({ ...specObject, [name]: TEXT_FIELD })	99✔
23		99✔
24	module.exports = async function createIndexes(collection, indexes, prefixOfIndexesToPreserve) {	99✔
25	let alreadyPresentIndexes = []	3,891✔
26	const indexNamesToMantain = []	3,891✔
27	const indexNamesToDrop = []	3,891✔
28	try {	3,891✔
29	alreadyPresentIndexes = await collection.indexes()	3,891✔
30	} catch (error) {	3,891✔
31	// throws if the collection doesn't exists...	3,568✔
32	}	3,568✔
33		3,891✔
34	const indexesNames = indexes.map(index => (index['name']))	3,891✔
35		3,891✔
36	alreadyPresentIndexes.forEach(foundIndex => {	3,891✔
37	if (	385✔
38	!foundIndex.name.startsWith(prefixOfIndexesToPreserve)	385✔
39	&& !foundIndex.key._id	385✔
40	&& !(	385✔
41	indexesNames.includes(foundIndex.name)	56✔
42	&& checkIndexEquality(foundIndex, indexes.find(idx => idx.name === foundIndex.name))	56✔
43	)	56✔
44	) {	385✔
45	indexNamesToDrop.push(foundIndex.name)	34✔
46	} else {	385✔
47	indexNamesToMantain.push(foundIndex.name)	351✔
48	}	351✔
49	})	3,891✔
50		3,891✔
51	await Promise.allSettled(indexNamesToDrop.map(name => collection.dropIndex(name)))	3,891✔
52		3,891✔
53	return Promise.allSettled(indexes	3,891✔
54	.filter(index => index.name !== MONGOID && !indexNamesToMantain.includes(index.name))	3,891✔
55	.map(index => createIndex(collection, index)))	3,891✔
56	}	3,891✔
57		99✔
58	async function createIndex(collection, index) {	4,811✔
59	let spec	4,811✔
60		4,811✔
61	switch (index.type) {	4,811✔
62	case NORMAL_INDEX: {	4,811✔
63	spec = index.fields.reduce(addKeyToSpec, {})	3,188✔
64	break	3,188✔
65	}	3,188✔
66	case GEO_INDEX: {	4,811✔
67	const { field } = index	912✔
68	spec = { [field]: GEO_FIELD }	912✔
69	break	912✔
70	}	912✔
71	case HASHED_INDEX: {	4,811✔
72	const { field } = index	21✔
73	spec = { [field]: HASHED_FIELD }	21✔
74	break	21✔
75	}	21✔
76	case TEXT_INDEX: {	4,811✔
77	spec = index.fields.reduce(addTextKeyToSpec, {})	690✔
78	break	690✔
79	}	690✔
80	default: {	4,811!
81	throw new Error(`Cannot create index of type ${index?.type}`)	×
82	}	×
83	}	4,811✔
84		4,811✔
85	const options = getIndexOptions(index)	4,811✔
86	return collection.createIndex(spec, options)	4,811✔
87	}	4,811✔
88		99✔
89	function getIndexOptions(index) {	4,811✔
90	let options = {	4,811✔
91	name: index.name,	4,811✔
92	unique: index.unique \|\| false,	4,811✔
93	background: true,	4,811✔
94	}	4,811✔
95		4,811✔
96	if (index.expireAfterSeconds) {	4,811✔
97	options = { ...options, expireAfterSeconds: index.expireAfterSeconds }	243✔
98	}	243✔
99	if (index.weights) {	4,811✔
100	options = { ...options, weights: index.weights }	681✔
101	}	681✔
102	if (index.defaultLanguage) {	4,811✔
103	options = { ...options, default_language: index.defaultLanguage }	681✔
104	}	681✔
105	if (index.languageOverride) {	4,811✔
106	options = { ...options, language_override: index.languageOverride }	681✔
107	}	681✔
108	if (index.usePartialFilter) {	4,811✔
109	let partialFilterExpression	237✔
110	try {	237✔
111	partialFilterExpression = index.partialFilterExpression ? JSON.parse(index.partialFilterExpression) : {}	237!
112	} catch (error) {	237!
113	throw new Error(`Impossible to parse the Partial Index expression of index ${index.name}`, { catch: error })	×
114	}	×
115		237✔
116	options = { ...options, partialFilterExpression }	237✔
117	}	237✔
118	return options	4,811✔
119	}	4,811✔
120		99✔
121	function checkIndexEquality(foundIndex, index) {	47✔
122	const isOptionUniqueEqual = index.unique ? foundIndex.unique === true : foundIndex.unique === undefined	47✔
123	const isOptionExpireAfterSecondsEqual = foundIndex.expireAfterSeconds === index.expireAfterSeconds	47✔
124	return (	47✔
125	isOptionUniqueEqual	47✔
126	&& isOptionExpireAfterSecondsEqual	47✔
127	&& checkIndexEqualityByType(foundIndex, index)	47✔
128	)	47✔
129	}	47✔
130		99✔
131	function checkIndexEqualityByType(foundIndex, index) {	41✔
132	switch (index.type) {	41✔
133	case NORMAL_INDEX: {	41✔
134	const expectedKey = index.fields.reduce(addKeyToSpec, {})	19✔
135	return JSON.stringify(foundIndex.key) === JSON.stringify(expectedKey)	19✔
136	}	19✔
137	case GEO_INDEX: {	41✔
138	return foundIndex.key[index.field] === GEO_FIELD	12✔
139	}	12✔
140	case HASHED_INDEX: {	41✔
141	return foundIndex.key[index.field] === HASHED_FIELD	9✔
142	}	9✔
143	case TEXT_INDEX: {	41✔
UNCOV 144	const expectedKey = index.fields.reduce(addTextKeyToSpec, {})	1✔
UNCOV 145	return JSON.stringify(foundIndex.key) === JSON.stringify(expectedKey)	1✔
UNCOV 146	}	1✔
147	default:	41!
148	return false	×
149	}	41✔
150	}	41✔

mia-platform / crud-service / 10511826445

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous