10963212344

Committed 20 Sep 2024 04:52PM UTC coverage: 97.27% (-0.1%) from 97.368%

Build # 10963212344

Build Type

push

github

Committed by

web-flow

Commit Message

fix: support array of object ids and $size operator (#376)

* wip: implemented working support for objectid arrays

* fix(types): introduce support for array of ObjectIds at documents root level

* fix(operators): introduce support for  operator in _q query param for array fields

Run Details

1433 of 1537 branches covered (93.23%)

Branch coverage included in aggregate %.

214 of 228 new or added lines in 4 files covered. (93.86%)

3 existing lines in 1 file now uncovered.

9257 of 9453 relevant lines covered (97.93%)

7900.72 hits per line

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

93.3

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

mia-platform / crud-service / 10963212344

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