7573381968

Committed 18 Jan 2024 04:58PM UTC coverage: 97.018% (+0.02%) from 96.995%

Build # 7573381968

Build Type

Pull #250

github

Committed by

web-flow

Commit Message

Merge 3b45e8de4 into 976dd5fd2

Pull Request Pull Request #250: Feat: default sorting

Run Details

1700 of 1843 branches covered (0.0%)

Branch coverage included in aggregate %.

37 of 37 new or added lines in 3 files covered. (100.0%)

3 existing lines in 1 file now uncovered.

8615 of 8789 relevant lines covered (98.02%)

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

mia-platform / crud-service / 7573381968

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