mirror of
https://github.com/hcengineering/platform.git
synced 2025-02-04 01:46:24 +00:00
119 lines
3.6 KiB
TypeScript
119 lines
3.6 KiB
TypeScript
//
|
|
// Copyright © 2022 Hardcore Engineering Inc.
|
|
//
|
|
// Licensed under the Eclipse Public 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 https://www.eclipse.org/legal/epl-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.
|
|
//
|
|
|
|
import {
|
|
Class,
|
|
Doc,
|
|
DocumentQuery,
|
|
FindOptions,
|
|
FindResult,
|
|
MeasureContext,
|
|
Ref,
|
|
clone,
|
|
toFindResult
|
|
} from '@hcengineering/core'
|
|
import { BaseMiddleware, Middleware, type PipelineContext } from '@hcengineering/server-core'
|
|
/**
|
|
* @public
|
|
*/
|
|
export class LookupMiddleware extends BaseMiddleware implements Middleware {
|
|
private constructor (context: PipelineContext, next?: Middleware) {
|
|
super(context, next)
|
|
}
|
|
|
|
static async create (
|
|
ctx: MeasureContext,
|
|
context: PipelineContext,
|
|
next: Middleware | undefined
|
|
): Promise<LookupMiddleware> {
|
|
return new LookupMiddleware(context, next)
|
|
}
|
|
|
|
override async findAll<T extends Doc>(
|
|
ctx: MeasureContext,
|
|
_class: Ref<Class<T>>,
|
|
query: DocumentQuery<T>,
|
|
options?: FindOptions<T>
|
|
): Promise<FindResult<T>> {
|
|
const result = await this.provideFindAll(ctx, _class, query, options)
|
|
// Fill lookup map to make more compact representation
|
|
|
|
if (options?.lookup !== undefined) {
|
|
const newResult: T[] = []
|
|
let counter = 0
|
|
const idClassMap: Record<string, { id: number, doc: Doc, count: number }> = {}
|
|
|
|
function mapDoc (doc: Doc): number {
|
|
const key = doc._class + '@' + doc._id
|
|
let docRef = idClassMap[key]
|
|
if (docRef === undefined) {
|
|
docRef = { id: ++counter, doc, count: -1 }
|
|
idClassMap[key] = docRef
|
|
}
|
|
docRef.count++
|
|
return docRef.id
|
|
}
|
|
|
|
for (const d of result) {
|
|
const newDoc: any = { ...d }
|
|
if (d.$lookup !== undefined) {
|
|
newDoc.$lookup = clone(d.$lookup)
|
|
newResult.push(newDoc)
|
|
for (const [k, v] of Object.entries(d.$lookup)) {
|
|
if (!Array.isArray(v)) {
|
|
newDoc.$lookup[k] = v != null ? mapDoc(v) : v
|
|
} else {
|
|
newDoc.$lookup[k] = v.map((it) => (it != null ? mapDoc(it) : it))
|
|
}
|
|
}
|
|
} else {
|
|
newResult.push(newDoc)
|
|
}
|
|
}
|
|
const lookupMap = Object.fromEntries(Array.from(Object.values(idClassMap)).map((it) => [it.id, it.doc]))
|
|
return this.cleanQuery<T>(toFindResult(newResult, result.total, lookupMap), query, lookupMap)
|
|
}
|
|
|
|
// We need to get rid of simple query parameters matched in documents
|
|
return this.cleanQuery<T>(result, query)
|
|
}
|
|
|
|
private cleanQuery<T extends Doc>(
|
|
result: FindResult<T>,
|
|
query: DocumentQuery<T>,
|
|
lookupMap?: Record<string, Doc>
|
|
): FindResult<T> {
|
|
const newResult: T[] = []
|
|
for (const doc of result) {
|
|
let _doc = doc
|
|
let cloned = false
|
|
for (const [k, v] of Object.entries(query)) {
|
|
if (typeof v === 'string' || typeof v === 'number' || typeof v === 'boolean') {
|
|
if ((_doc as any)[k] === v) {
|
|
if (!cloned) {
|
|
_doc = { ...doc } as any
|
|
cloned = true
|
|
}
|
|
// eslint-disable-next-line @typescript-eslint/no-dynamic-delete
|
|
delete (_doc as any)[k]
|
|
}
|
|
}
|
|
}
|
|
newResult.push(_doc)
|
|
}
|
|
return toFindResult(newResult, result.total, lookupMap)
|
|
}
|
|
}
|