@candlerip/shared 0.0.76 → 0.0.80

package/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/database/aggregate/candle/utils/compose-get-candle-aggregates/type.js

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

package/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/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/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/database/aggregate/candle/utils/compose-get-candles-aggregates/type.js

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

package/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/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/database/aggregate/candle-lighting-profile/index.d.ts

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

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

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

package/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/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/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/database/aggregate/candle-lighting-profile/utils/compose-get-lighting-profile-aggregates/type.js

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

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

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

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

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

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

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

package/database/aggregate/country/index.js

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

package/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/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/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/database/aggregate/country/utils/compose-get-country-aggregates/type.js

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

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

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

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

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

package/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/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/database/aggregate/person/index.d.ts

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

package/database/aggregate/person/index.js

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

package/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/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/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/database/aggregate/person/utils/compose-get-person-aggregates/type.js

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

package/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;

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

@@ -0,0 +1,67 @@
+import { isUndefined } from '../../../../../common/index.js';
+import { composeGetPersonAggregates } from '../compose-get-person-aggregates/index.js';
+export const composeGetPersonsAggregates = (props) => {
+    const { count, isProposable, name, isNameCaseSensitive, placeOfBirths, skipCount, sortName, sortOrder, userId, withPhoto, withCandlesCount, withBirthPlaceCountry, } = props;
+    let aggregates = [];
+    if (name) {
+        aggregates.push({
+            $match: {
+                name: { $regex: name, $options: !isNameCaseSensitive ? 'i' : '' },
+            },
+        });
+    }
+    if (userId) {
+        aggregates.push({ $match: { userId } });
+    }
+    if (!isUndefined(isProposable)) {
+        aggregates.push({ $match: { isProposable } });
+    }
+    if (withPhoto) {
+        aggregates.push({
+            $match: {
+                images: {
+                    $ne: null,
+                },
+            },
+        });
+    }
+    if (placeOfBirths) {
+        aggregates.push({
+            $match: {
+                'birth.place.countryCode': {
+                    $in: placeOfBirths,
+                },
+            },
+        });
+    }
+    aggregates = aggregates.concat(composeGetPersonAggregates({
+        isProposable,
+        withCandlesCount,
+        withBirthPlaceCountry,
+    }));
+    aggregates.push({
+        $sort: {
+            [sortName]: sortOrder === 'asc' ? 1 : -1,
+        },
+    });
+    const dataAggregates = [...aggregates];
+    if (skipCount) {
+        dataAggregates.push({
+            $skip: skipCount,
+        });
+    }
+    const facetAggregates = [
+        {
+            $facet: {
+                data: [
+                    ...dataAggregates,
+                    {
+                        $limit: count,
+                    },
+                ],
+                total: [...aggregates, { $count: 'totalCount' }],
+            },
+        },
+    ];
+    return facetAggregates;
+};

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

@@ -0,0 +1,16 @@
+import { PipelineStage, SortOrder } from 'mongoose';
+import { CountryCode, PersonSortName } from '../../../../../common/index.js';
+export type ComposeGetPersonsAggregates = (props: {
+    count: number;
+    isProposable?: boolean;
+    name?: string;
+    isNameCaseSensitive?: boolean;
+    placeOfBirths?: CountryCode[];
+    skipCount?: number;
+    sortName: PersonSortName;
+    sortOrder: SortOrder;
+    userId?: string;
+    withPhoto?: boolean;
+    withCandlesCount?: boolean;
+    withBirthPlaceCountry?: boolean;
+}) => PipelineStage[];

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

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

package/database/aggregate/person/utils/index.d.ts

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

package/database/aggregate/person/utils/index.js

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

package/database/aggregate/translation/index.d.ts

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

package/database/aggregate/translation/index.js

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

package/database/aggregate/translation/utils/compose-get-translations-as-dictionary-aggregates/index.d.ts

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

package/database/aggregate/translation/utils/compose-get-translations-as-dictionary-aggregates/index.js

@@ -0,0 +1,39 @@
+export const composeGetTranslationsAsDictionaryAggregates = ({ codes, language }) => {
+    let aggregates = [];
+    if (codes) {
+        aggregates.push({
+            $match: {
+                code: {
+                    $in: codes,
+                },
+            },
+        });
+    }
+    aggregates = aggregates.concat([
+        {
+            $project: {
+                code: 1,
+                [language]: 1,
+            },
+        },
+        {
+            $group: {
+                _id: null,
+                root: {
+                    $push: {
+                        k: '$code',
+                        v: `$${language}`,
+                    },
+                },
+            },
+        },
+        {
+            $replaceRoot: {
+                newRoot: {
+                    $arrayToObject: '$root',
+                },
+            },
+        },
+    ]);
+    return aggregates;
+};

package/database/aggregate/translation/utils/compose-get-translations-as-dictionary-aggregates/type.d.ts

@@ -0,0 +1,6 @@
+import { PipelineStage } from 'mongoose';
+import { Language, TranslationCode } from '../../../../../common/index.js';
+export type ComposeGetTranslationsAsDictionaryAggregates = (props: {
+    language: Language;
+    codes?: readonly TranslationCode[];
+}) => PipelineStage[];

package/database/aggregate/translation/utils/compose-get-translations-as-dictionary-aggregates/type.js

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

package/database/aggregate/translation/utils/index.d.ts

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

package/database/aggregate/translation/utils/index.js

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

package/database/connection/index.d.ts

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

package/database/connection/index.js

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

package/database/connection/utils/connect-database/index.d.ts

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

package/database/connection/utils/connect-database/index.js

@@ -0,0 +1,12 @@
+import mongoose from 'mongoose';
+export const connectDatabase = async (url) => {
+    const { readyState } = mongoose.connections[0];
+    if (readyState === 0 || readyState === 3) {
+        try {
+            await mongoose.connect(url);
+        }
+        catch {
+            setTimeout(connectDatabase, 5000);
+        }
+    }
+};

package/database/connection/utils/connect-database/type.d.ts

@@ -0,0 +1 @@
+export type ConnectDatabase = (url: string) => Promise<void>;

package/database/connection/utils/connect-database/type.js

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