@candlerip/shared 0.0.46 → 0.0.51

package/src/backend/database/aggregate/candle/utils/compose-get-candle-aggregates/index.js

@@ -0,0 +1,221 @@
+import { Types } from 'mongoose';
+export const composeGetCandleAggregates = (props) => {
+    const { _id, lighting, withPerson } = props;
+    const { all: allLightings, last: lastLighting, count: lightingsCount, original: originalLightings } = lighting;
+    let aggregates = [];
+    if (_id) {
+        aggregates.push({
+            $match: {
+                _id: new Types.ObjectId(_id),
+            },
+        });
+    }
+    aggregates = aggregates.concat([
+        {
+            $unset: ['createdAt'],
+        },
+    ]);
+    if (withPerson) {
+        aggregates = aggregates.concat([
+            {
+                $lookup: {
+                    from: 'persons',
+                    localField: 'personId',
+                    foreignField: '_id',
+                    as: 'person',
+                },
+            },
+            {
+                $unset: ['person.createdAt'],
+            },
+            {
+                $unwind: {
+                    path: '$person',
+                    preserveNullAndEmptyArrays: true,
+                },
+            },
+            {
+                $lookup: {
+                    from: 'countries',
+                    localField: 'person.birth.place.countryCode',
+                    foreignField: 'code',
+                    as: 'person.birth.place.country',
+                },
+            },
+            {
+                $unwind: {
+                    path: '$person.birth.place.country',
+                    preserveNullAndEmptyArrays: true,
+                },
+            },
+            {
+                $unset: ['person.birth.place.countryCode'],
+            },
+        ]);
+    }
+    if (lastLighting) {
+        aggregates = aggregates.concat([
+            {
+                $addFields: {
+                    lastLighting: { $last: '$lightings' },
+                },
+            },
+            {
+                $lookup: {
+                    from: 'candlelightingprofiles',
+                    localField: 'lastLighting.candleLightingProfileCode',
+                    foreignField: 'code',
+                    as: 'lastLighting.candleLightingProfile',
+                },
+            },
+            {
+                $unwind: {
+                    path: '$lastLighting.candleLightingProfile',
+                    preserveNullAndEmptyArrays: true,
+                },
+            },
+            {
+                $unset: 'lastLighting.candleLightingProfileCode',
+            },
+        ]);
+    }
+    if (allLightings) {
+        aggregates = aggregates.concat([
+            {
+                $lookup: {
+                    from: 'candlelightingprofiles',
+                    localField: 'lightings.candleLightingProfileCode',
+                    foreignField: 'code',
+                    as: 'lightingsTemp',
+                },
+            },
+            {
+                $set: {
+                    allLightings: {
+                        $map: {
+                            input: '$lightings',
+                            in: {
+                                $mergeObjects: [
+                                    '$$this',
+                                    {
+                                        candleLightingProfile: {
+                                            $arrayElemAt: [
+                                                '$lightingsTemp',
+                                                {
+                                                    $indexOfArray: ['$lightingsTemp.code', '$$this.candleLightingProfileCode'],
+                                                },
+                                            ],
+                                        },
+                                    },
+                                ],
+                            },
+                        },
+                    },
+                },
+            },
+            {
+                $unset: ['lightingsTemp'],
+            },
+        ]);
+    }
+    if (lightingsCount) {
+        aggregates = aggregates.concat([
+            {
+                $addFields: {
+                    lightingsCount: {
+                        $size: {
+                            $ifNull: ['$lightings', []],
+                        },
+                    },
+                },
+            },
+        ]);
+    }
+    if (!originalLightings) {
+        aggregates = aggregates.concat([
+            {
+                $unset: ['lightings'],
+            },
+        ]);
+    }
+    if (withPerson) {
+        aggregates = aggregates.concat([
+            {
+                $unset: ['personId'],
+            },
+            {
+                $set: {
+                    'person.birth.place': {
+                        $cond: [
+                            {
+                                $ne: ['$person.birth.place', {}],
+                            },
+                            '$person.birth.place',
+                            '$$REMOVE',
+                        ],
+                    },
+                },
+            },
+            {
+                $set: {
+                    'person.birth': {
+                        $cond: [
+                            {
+                                $ne: ['$person.birth', {}],
+                            },
+                            '$person.birth',
+                            '$$REMOVE',
+                        ],
+                    },
+                },
+            },
+            {
+                $set: {
+                    person: {
+                        $cond: [
+                            {
+                                $ne: ['$person', {}],
+                            },
+                            '$person',
+                            '$$REMOVE',
+                        ],
+                    },
+                },
+            },
+        ]);
+    }
+    aggregates = aggregates.concat([
+        {
+            $set: {
+                lastLighting: {
+                    $cond: [
+                        {
+                            $ne: ['$lastLighting', {}],
+                        },
+                        '$lastLighting',
+                        '$$REMOVE',
+                    ],
+                },
+                lightings: {
+                    $cond: [
+                        {
+                            $ne: ['$lightings', null],
+                        },
+                        '$lightings',
+                        '$$REMOVE',
+                    ],
+                },
+                lightingsCount: {
+                    $cond: [
+                        {
+                            $ne: ['$lightingsCount', 0],
+                        },
+                        '$lightingsCount',
+                        '$$REMOVE',
+                    ],
+                },
+            },
+        },
+    ]);
+    return aggregates;
+};

package/src/backend/database/aggregate/candle/utils/compose-get-candle-aggregates/type.d.ts

@@ -0,0 +1,7 @@
+import { PipelineStage } from 'mongoose';
+import { CandleLighting } from '../../../../model/index.js';
+export type ComposeGetCandleAggregates = (props: {
+    _id?: string;
+    lighting: CandleLighting;
+    withPerson?: boolean;
+}) => PipelineStage[];

package/src/backend/database/aggregate/candle/utils/compose-get-candles-aggregates/index.d.ts

@@ -0,0 +1,2 @@
+import { ComposeGetCandlesAggregates } from './type.js';
+export declare const composeGetCandlesAggregates: ComposeGetCandlesAggregates;

package/src/backend/database/aggregate/candle/utils/compose-get-candles-aggregates/index.js

@@ -0,0 +1,103 @@
+import { Types } from 'mongoose';
+import { composeGetCandleAggregates } from '../compose-get-candle-aggregates/index.js';
+export const composeGetCandlesAggregates = (props) => {
+    const { burningStates, count, lighting, personId, skipCount, sortName, sortOrder, userId, withPerson } = props;
+    const { last: lastLightings } = lighting;
+    let aggregates = [];
+    if (personId) {
+        aggregates.push({ $match: { personId: new Types.ObjectId(personId) } });
+    }
+    if (userId) {
+        aggregates.push({ $match: { userId } });
+    }
+    aggregates = aggregates.concat(composeGetCandleAggregates({
+        lighting: {
+            ...lighting,
+            last: true,
+        },
+        withPerson,
+    }));
+    if (burningStates) {
+        aggregates = aggregates.concat([
+            {
+                $addFields: {
+                    'lastLighting.burningEndsAt': {
+                        $dateAdd: {
+                            startDate: '$lastLighting.burningStartsAt',
+                            unit: 'second',
+                            amount: '$lastLighting.candleLightingProfile.burningSeconds',
+                        },
+                    },
+                },
+            },
+            {
+                $match: {
+                    $or: burningStates.map((it) => ({
+                        'lastLighting.burningEndsAt': it === 'burning'
+                            ? {
+                                $gte: new Date(),
+                            }
+                            : {
+                                $lte: new Date(),
+                            },
+                    })),
+                },
+            },
+        ]);
+    }
+    if (sortName === 'burningEndsAt' || sortName === 'burningStartsAt') {
+        aggregates.push({
+            $addFields: {
+                'lastLighting.burningEndsAt': {
+                    $dateAdd: {
+                        startDate: '$lastLighting.burningStartsAt',
+                        unit: 'second',
+                        amount: '$lastLighting.candleLightingProfile.burningSeconds',
+                    },
+                },
+            },
+        });
+        aggregates.push({
+            $sort: {
+                [`lastLighting.${sortName}`]: sortOrder === 'asc' ? 1 : -1,
+            },
+        });
+        aggregates.push({
+            $unset: 'lastLighting.burningEndsAt',
+        });
+    }
+    else {
+        aggregates.push({
+            $sort: {
+                [sortName === 'litName' ? sortName : 'lastLighting.burningStartsAt']: sortOrder === 'asc' ? 1 : -1,
+            },
+        });
+    }
+    if (!lastLightings) {
+        aggregates = aggregates.concat([
+            {
+                $unset: ['lastLighting'],
+            },
+        ]);
+    }
+    const dataAggregates = [...aggregates];
+    if (skipCount) {
+        dataAggregates.push({
+            $skip: skipCount,
+        });
+    }
+    const facetAggregates = [
+        {
+            $facet: {
+                data: [
+                    ...dataAggregates,
+                    {
+                        $limit: count,
+                    },
+                ],
+                total: [...aggregates, { $count: 'totalCount' }],
+            },
+        },
+    ];
+    return facetAggregates;
+};

package/src/backend/database/aggregate/candle/utils/compose-get-candles-aggregates/type.d.ts

@@ -0,0 +1,14 @@
+import { PipelineStage, SortOrder } from 'mongoose';
+import { CandleLighting } from '../../../../model/index.js';
+import { BurningCandleState, CandleSortName } from '../../../../../../common/index.js';
+export type ComposeGetCandlesAggregates = (props: {
+    burningStates?: BurningCandleState[];
+    count: number;
+    lighting: CandleLighting;
+    personId?: string;
+    skipCount?: number;
+    sortName: CandleSortName;
+    sortOrder: SortOrder;
+    userId?: string;
+    withPerson?: boolean;
+}) => PipelineStage[];

package/src/backend/database/aggregate/candle/utils/index.d.ts

@@ -0,0 +1,2 @@
+export * from './compose-get-candle-aggregates/index.js';
+export * from './compose-get-candles-aggregates/index.js';

package/src/backend/database/aggregate/candle/utils/index.js

@@ -0,0 +1,2 @@
+export * from './compose-get-candle-aggregates/index.js';
+export * from './compose-get-candles-aggregates/index.js';

package/src/backend/database/aggregate/candle-lighting-profile/index.d.ts

@@ -0,0 +1 @@
+export * from './utils/index.js';

package/src/backend/database/aggregate/candle-lighting-profile/index.js

@@ -0,0 +1 @@
+export * from './utils/index.js';

package/src/backend/database/aggregate/candle-lighting-profile/utils/compose-get-lighting-profile-aggregates/index.d.ts

@@ -0,0 +1,2 @@
+import { ComposeGetCandleLightingProfileAggregates } from './type.js';
+export declare const composeGetCandleLightingProfileAggregates: ComposeGetCandleLightingProfileAggregates;

package/src/backend/database/aggregate/candle-lighting-profile/utils/compose-get-lighting-profile-aggregates/index.js

@@ -0,0 +1,10 @@
+export const composeGetCandleLightingProfileAggregates = (code) => {
+    const aggregates = [
+        {
+            $match: {
+                code,
+            },
+        },
+    ];
+    return aggregates;
+};

package/src/backend/database/aggregate/candle-lighting-profile/utils/compose-get-lighting-profile-aggregates/type.d.ts

@@ -0,0 +1,2 @@
+import { PipelineStage } from 'mongoose';
+export type ComposeGetCandleLightingProfileAggregates = (code: number) => PipelineStage[];

package/src/backend/database/aggregate/candle-lighting-profile/utils/index.d.ts

@@ -0,0 +1 @@
+export * from './compose-get-lighting-profile-aggregates/index.js';

package/src/backend/database/aggregate/candle-lighting-profile/utils/index.js

@@ -0,0 +1 @@
+export * from './compose-get-lighting-profile-aggregates/index.js';

package/src/backend/database/aggregate/country/index.d.ts

@@ -0,0 +1 @@
+export * from './utils/index.js';

package/src/backend/database/aggregate/country/index.js

@@ -0,0 +1 @@
+export * from './utils/index.js';

package/src/backend/database/aggregate/country/utils/compose-get-country-aggregates/index.d.ts

@@ -0,0 +1,2 @@
+import { ComposeCountryAggregates } from './type.js';
+export declare const composeCountryAggregates: ComposeCountryAggregates;

package/src/backend/database/aggregate/country/utils/compose-get-country-aggregates/index.js

@@ -0,0 +1,36 @@
+export const composeCountryAggregates = (props) => {
+    const { code, withPersonsCount } = props;
+    let aggregates = [];
+    if (code) {
+        aggregates.push({
+            $match: {
+                code,
+            },
+        });
+    }
+    if (withPersonsCount) {
+        aggregates = aggregates.concat({
+            $lookup: {
+                from: 'persons',
+                localField: 'code',
+                foreignField: 'birth.place.countryCode',
+                as: 'personsTemp',
+            },
+        }, {
+            $addFields: {
+                personsCount: {
+                    $size: '$personsTemp',
+                },
+            },
+        }, {
+            $match: {
+                personsCount: {
+                    $ne: 0,
+                },
+            },
+        }, {
+            $unset: 'personsTemp',
+        });
+    }
+    return aggregates;
+};

package/src/backend/database/aggregate/country/utils/compose-get-country-aggregates/type.d.ts

@@ -0,0 +1,6 @@
+import { PipelineStage } from 'mongoose';
+import { CountryCode } from '../../../../../../common/index.js';
+export type ComposeCountryAggregates = (props: {
+    code?: CountryCode;
+    withPersonsCount?: boolean;
+}) => PipelineStage[];

package/src/backend/database/aggregate/country/utils/compose-get-country-aggregates/type.js

@@ -0,0 +1 @@
+export {};

package/src/backend/database/aggregate/country/utils/index.d.ts

@@ -0,0 +1 @@
+export * from './compose-get-country-aggregates/index.js';

package/src/backend/database/aggregate/country/utils/index.js

@@ -0,0 +1 @@
+export * from './compose-get-country-aggregates/index.js';

package/src/backend/database/aggregate/index.d.ts

@@ -0,0 +1,5 @@
+export * from './candle/index.js';
+export * from './candle-lighting-profile/index.js';
+export * from './country/index.js';
+export * from './person/index.js';
+export * from './translation/index.js';

package/src/backend/database/aggregate/index.js

@@ -0,0 +1,5 @@
+export * from './candle/index.js';
+export * from './candle-lighting-profile/index.js';
+export * from './country/index.js';
+export * from './person/index.js';
+export * from './translation/index.js';

package/src/backend/database/aggregate/person/index.d.ts

@@ -0,0 +1 @@
+export * from './utils/index.js';

package/src/backend/database/aggregate/person/index.js

@@ -0,0 +1 @@
+export * from './utils/index.js';

package/src/backend/database/aggregate/person/utils/compose-get-person-aggregates/index.d.ts

@@ -0,0 +1,2 @@
+import { ComposeGetPersonAggregates } from './type.js';
+export declare const composeGetPersonAggregates: ComposeGetPersonAggregates;

package/src/backend/database/aggregate/person/utils/compose-get-person-aggregates/index.js

@@ -0,0 +1,167 @@
+import { Types } from 'mongoose';
+import { isUndefined } from '../../../../../../common/index.js';
+export const composeGetPersonAggregates = (props) => {
+    const { _id, isProposable, size, withBirthPlaceCountry, withCandlesCount } = props;
+    let aggregates = [];
+    if (_id) {
+        aggregates.push({
+            $match: {
+                _id: new Types.ObjectId(_id),
+            },
+        });
+    }
+    if (!isUndefined(isProposable)) {
+        aggregates.push({ $match: { isProposable } });
+    }
+    if (withCandlesCount) {
+        aggregates = aggregates.concat([
+            {
+                $lookup: {
+                    from: 'candles',
+                    localField: '_id',
+                    foreignField: 'personId',
+                    as: 'candles',
+                },
+            },
+            {
+                $addFields: {
+                    candles: {
+                        $map: {
+                            input: '$candles',
+                            in: {
+                                $mergeObjects: [
+                                    '$$this',
+                                    {
+                                        lastLighting: { $last: '$$this.lightings' },
+                                    },
+                                ],
+                            },
+                        },
+                    },
+                },
+            },
+            {
+                $unset: 'candles.lightings',
+            },
+            {
+                $lookup: {
+                    from: 'candlelightingprofiles',
+                    localField: 'candles.lastLighting.candleLightingProfileCode',
+                    foreignField: 'code',
+                    as: 'candleLightingProfiles',
+                },
+            },
+            {
+                $addFields: {
+                    candles: {
+                        $map: {
+                            input: '$candles',
+                            as: 'candle',
+                            in: {
+                                $mergeObjects: [
+                                    '$$candle',
+                                    {
+                                        candleLightingProfile: {
+                                            $arrayElemAt: [
+                                                '$candleLightingProfiles',
+                                                { $indexOfArray: ['$candleLightingProfiles.code', '$$candle.lastLighting.candleLightingProfileCode'] },
+                                            ],
+                                        },
+                                    },
+                                ],
+                            },
+                        },
+                    },
+                },
+            },
+            {
+                $unset: ['candleLightingProfiles'],
+            },
+            {
+                $addFields: {
+                    candles: {
+                        $map: {
+                            input: '$candles',
+                            in: {
+                                $mergeObjects: [
+                                    '$$this',
+                                    {
+                                        burningEndsAt: {
+                                            $dateAdd: {
+                                                startDate: '$$this.lastLighting.burningStartsAt',
+                                                unit: 'second',
+                                                amount: '$$this.candleLightingProfile.burningSeconds',
+                                            },
+                                        },
+                                    },
+                                ],
+                            },
+                        },
+                    },
+                },
+            },
+            {
+                $addFields: {
+                    candlesCount: {
+                        burning: {
+                            $size: {
+                                $filter: {
+                                    input: '$candles',
+                                    as: 'candles',
+                                    cond: {
+                                        $gte: ['$$candles.burningEndsAt', new Date()],
+                                    },
+                                },
+                            },
+                        },
+                    },
+                },
+            },
+            {
+                $addFields: {
+                    candlesCount: {
+                        burned: {
+                            $size: {
+                                $filter: {
+                                    input: '$candles',
+                                    as: 'candles',
+                                    cond: {
+                                        $lte: ['$$candles.burningEndsAt', new Date()],
+                                    },
+                                },
+                            },
+                        },
+                    },
+                },
+            },
+            {
+                $unset: 'candles',
+            },
+        ]);
+    }
+    if (withBirthPlaceCountry) {
+        aggregates = aggregates.concat([
+            {
+                $lookup: {
+                    from: 'countries',
+                    localField: 'birth.place.countryCode',
+                    foreignField: 'code',
+                    as: 'birth.place.country',
+                },
+            },
+            {
+                $unwind: {
+                    path: '$birth.place.country',
+                    preserveNullAndEmptyArrays: true,
+                },
+            },
+            {
+                $unset: 'birth.place.countryCode',
+            },
+        ]);
+    }
+    if (size) {
+        aggregates.push({ $sample: { size: 1 } });
+    }
+    return aggregates;
+};

package/src/backend/database/aggregate/person/utils/compose-get-person-aggregates/type.d.ts

@@ -0,0 +1,8 @@
+import { PipelineStage } from 'mongoose';
+export type ComposeGetPersonAggregates = (props: {
+    _id?: string;
+    isProposable?: boolean;
+    size?: number;
+    withCandlesCount?: boolean;
+    withBirthPlaceCountry?: boolean;
+}) => PipelineStage[];

package/src/backend/database/aggregate/person/utils/compose-get-person-aggregates/type.js

@@ -0,0 +1 @@
+export {};

package/src/backend/database/aggregate/person/utils/compose-get-persons-aggregates/index.d.ts

@@ -0,0 +1,2 @@
+import { ComposeGetPersonsAggregates } from './type.js';
+export declare const composeGetPersonsAggregates: ComposeGetPersonsAggregates;